dead_ops.insert(vars.begin(), vars.end());

  // Removes relevant ops in topological order.
  for (auto& op : vars) RecursiveRemove(op, erase_list, dead_ops);

  // Erases the ops.
  for (auto op : erase_list) op->erase();
}

void RemoveVariablesInSessionInitializerPass::runOnOperation() {
  ModuleOp module_op = getOperation();

  for (auto init_func_op : GetInitializerFunctions(module_op)) {

      CreateRemoteRunCalls(context, *metadatas);

      // Erases the original operations which have been cloned in the remote
      // functions.
      for (auto &iter : *metadatas) {
        llvm::StringRef host = iter.first();
        FunctionMetadata &metadata = iter.second;
        // Do not erase operations placed on the localhost.
        if (IsOnLocalHost(host)) continue;

  while (!control_barrier_worklist.empty()) {
    Value control_barrier = control_barrier_worklist.front();
    control_barrier_worklist.pop();

    // We can only erase control barriers whose uses have been erased as well.
    if (!control_barrier.use_empty()) continue;

    // Only values defined by IslandOp were inserted in the worklist.

      dq.getOutput().replaceAllUsesWith(dcast);
      dq.erase();
    } else if (auto q = llvm::dyn_cast<QuantizeOp>(op)) {
      auto qcast = b.create<quantfork::QuantizeCastOp>(
          q.getLoc(), q.getOutput().getType(), q.getInput());
      q.getOutput().replaceAllUsesWith(qcast);
      q.erase();
    } else if (auto q = llvm::dyn_cast<ConstOp>(op)) {
      auto value = q.getValue();

    new_outputs.push_back(it->getSecond().size);
  }
  OpBuilder(old_terminator)
      .create<TerminatorOp>(old_terminator->getLoc(), new_outputs);
  old_terminator->erase();
  return output_buffer_to_size;
}

// Adds the corresponding sizes of tensor list buffers in func's return values
// to the list of return values. Returns the mapping from the buffer indices to

      }

      read_variable_op.erase();
      continue;
    }

    if (auto assign_variable_op = dyn_cast<TF::AssignVariableOp>(&op)) {
      Value resource = assign_variable_op.getResource();
      auto last_store = resource_handle_to_last_store_op[resource];
      // Previous store ops to same resource can be erased.
      if (last_store) last_store.erase();

              new_q_op.getResult());
          assign_variable_op->replaceAllUsesWith(new_assign_variable_op);
        }
        assign_variable_op.erase();
        dq_op.erase();
      } else {
        // Add quantize op.
        builder.setInsertionPoint(assign_variable_op);
        auto new_q_op = builder.create<QuantizeOp>(
            assign_variable_op.getLoc(), ref_qtype,

  builder.create<mlir::tf_device::ReturnOp>(result_op->getLoc(), results);

  // Then erase all the identity and partitioned output ops.
  for (const auto& [_, ops] : partitioned_outputs) {
    for (mlir::TF::TPUPartitionedOutputV2Op op : ops) {
      op->erase();
    }
  }

  for (mlir::TF::IdentityOp to_erase : erase_list) {
    to_erase->erase();
  }

  return result_op;
}

      builder.create<mlir::ml_program::GlobalStoreOp>(op.getLoc(), sym,
                                                      op.getValue());
      op.erase();
    });
    if (!success) return failure();

    // Erase tf_saved_model attributes we consumed. We can't delete them
    // right away, since they might weave through blocks, but we can replace
    // them with a dummy which DCE can pick up later.

  // directly.
  auto read_only_vars_fn = [&variable_v2s_to_replace](
                               VariableV2Op variable_v2_op) {
    if (variable_v2_op.getResult().use_empty()) {
      // Erase the op when there is no user.
      variable_v2_op.erase();
      return mlir::WalkResult::advance();
    }
    if (!all_of(variable_v2_op.getResult().getUsers(), [&variable_v2_op](