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