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