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