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