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