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