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