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