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