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