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