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