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