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