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