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