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