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