return this;
        }

        @Override
        public AnsiContext eraseForward() {
            delegate.eraseLine(Ansi.Erase.FORWARD);
            return this;
        }

        @Override
        public AnsiContext eraseAll() {
            delegate.eraseLine(Ansi.Erase.ALL);
            return this;
        }

        @Override
        public AnsiContext cursorAt(Cursor cursor) {

      /*operands=*/merged_else_yield_values);
}

// Merge the IfRegions in each segment. In the meantime, the old IfRegions in
// the segment will be added to `regions_to_remove`. They will be erased in the
// end.
// `if_op_segment` refers to segments of IfRegions. `moved_op_list` refers to
// the ops to be moved after new merged IfRegion. `regions_to_remove` refers to

    // we replace that block-argument's uses with the same (implicitly captured)
    // token 'token', used for If op, and erase the argument.
    // Note that 'RewriteControlFlowOpRegion' sets the token, used for the first
    // operation of region_idx'th region, to the dummy block-argument. As we
    // erase that argument, we also need to make sure that the token used for
    // the next operation is set to 'token'.

                            ? WalkResult::advance()
                            : WalkResult::interrupt();
               })
               .wasInterrupted()) {
        unscheduled_ops.erase(&unscheduled_op);
        num_partitions_after += op_partition && (scheduled_something == false);
        scheduled_something = true;
        // Schedule the operation by moving it to the start.

        load = builder.create<TF::CastOp>(op.getLoc(), op.getValue().getType(),
                                          load->getResult(0));
      }
      op.getResult().replaceAllUsesWith(load->getResult(0));
      op.erase();
    });

    module.walk([&](TF::AssignVariableOp op) {
      Operation* source = GetHandleSource(op, solver);
      if (!source) return;
      ml_program::GlobalOp globalOp =

      attr->contains("Truncate") && !attr->at("Truncate").b()) {
    node_def->set_op("Identity");
    attr->insert({{"T", attr->at("SrcT")}});
    attr->erase("SrcT");
    attr->erase("DstT");
    attr->erase("Truncate");
  }
}

}  // namespace

Status GetAttrValuesFromOperation(
    mlir::Operation* inst, llvm::StringRef name,
    const tensorflow::OpRegistrationData* op_reg_data,

          op->getLoc(), DenseIntElementsAttr::get(
                            RankedTensorType::get({}, builder.getI64Type()),
                            {device_ordinal}));
      op->replaceAllUsesWith(const_op);
      op->erase();
      return WalkResult::advance();
    }

    if (!devices.has_value()) return WalkResult::advance();

    // Map aliased devices to explicit devices based on replica.

      }
    }
    state.addOperands(operands);
    Operation* new_op = builder.create(state);
    item.replaceAllUsesWith(new_op);
    new_op->setAttrs(item.getAttrDictionary());
    item.erase();
  }
  AddStatefulControlFlowDependencies(graph_op);
}

// Populates an empty IslandOp and with a NoOp or Identity/IdentityN depending
// on if there are any data results.

      return failure();
    }
    ops_move[0]->remove();
    builder->insert(ops_move[0]);
    parallel_execute.replaceAllUsesWith(ops_move[0]);
    parallel_execute.erase();
  }
  return success();
}

}  // namespace TF

  absl::btree_set<char> reduced_label_set(input_subs.begin(), input_subs.end());
  for (const char x : output_subs) {
    reduced_label_set.erase(x);
  }
  for (const char x : other_subs) {
    reduced_label_set.erase(x);
  }
  reduced_label_set.erase('.');

  // Obtain the input subscripts with the reduced axis labels removed. E.g.
  // "ac" in the above example.
  std::string left_subs;