while (!todo.empty()) {
      Value value = todo.front();
      todo.pop();
      // All operations that have all their inputs available are good to go.
      // Uses, not Users, in case getUsers ever dedups.
      for (OpOperand& operand : value.getUses()) {
        Operation* user = ancestor[operand.getOwner()];
        remaining_incoming_data_edges[user]--;
        if (remaining_incoming_data_edges[user] == 0 &&

  // ops in first_if and the ops in second_if, it's not safe to merge
  // them.
  std::vector<Operation*> dependencies;
  for (auto* user : first_if.getOperation()->getUsers()) {
    if (!downstream_if_ops.contains(user)) {
      dependencies.push_back(user);
    }
  }
  for (auto* successor :
       side_effect_analysis.DirectControlSuccessors(first_if.getOperation())) {

      min -= kNearZeroTolerance;
      max += kNearZeroTolerance;
    }
  }
};

template <typename VerifierT>
bool UsedBy(Operation* op) {
  for (Operation* user : op->getUsers()) {
    if (llvm::isa_and_nonnull<VerifierT>(user)) return true;
  }
  return false;
}

template <typename VerifierT>
void CreateVerifier(Operation* quantizing_op, Operation* quantized_op,

        value.setType(CloneTypeWithNewElementType(value.getType(),
                                                  rewriter.getF32Type()));
        rewriter.setInsertionPointAfterValue(value);
        for (Operation* user : op->getUsers()) {
          for (int i = 0; i < user->getNumOperands(); i++) {
            if (user->getOperand(i) == value) {
              Value bf16_cast = rewriter.create<TF::CastOp>(
                  user->getLoc(),

        head_outside_compiled_ops.insert(&cluster_op);
    }
  }

  for (auto head_outside_compiled_op :
       llvm::reverse(head_outside_compiled_ops)) {
    auto users = head_outside_compiled_op->getUsers();
    if (users.empty() ||
        HasOutsideCompilationAttribute(head_outside_compiled_op))
      continue;

    bool should_expand_op_to_host_computation = true;
    for (auto consumer_op : users) {

      made_changes = false;
      for (auto func :
           llvm::make_early_inc_range(module.getOps<func::FuncOp>())) {
        ArrayRef<Operation *> users = symbol_users.getUsers(func);
        if (users.size() <= 1) {
          continue;
        }

        // At this point, we know we are going to change the module.
        made_changes = true;

  for (const auto &[resource_handle, var_handle_ops] : resources) {
    if (std::all_of(var_handle_ops.begin(), var_handle_ops.end(),
                    [](Operation *op) {
                      for (auto *user : op->getUsers()) {
                        if (!OnlyHasReadEffect(user)) return false;
                      }
                      return true;
                    })) {
      read_only_vars.insert(resource_handle);
    }

  for (Operation& op : region->front()) {
    for (Value v : op.getResults()) {
      // A value is live-out if any of its users are not inside value producer's
      // region.
      bool is_live_out = llvm::any_of(v.getUsers(), [&](Operation* user) {
        return !region->isAncestor(user->getParentRegion());
      });

      if (is_live_out) live_outs->emplace_back(v);
    }
  }
}

  LogicalResult matchAndRewrite(func::CallOp call_op,
                                PatternRewriter& rewriter) const override {
    if (call_op.getNumResults() != 1) return failure();
    auto users = call_op->getUsers();
    for (auto user : users) {
      if (!llvm::isa<mlir::stablehlo::UniformDequantizeOp>(user)) {
        return failure();
      }
    }
    auto func_name = call_op.getCallee();

  queue.push(root_op);
  while (!queue.empty()) {
    Operation* op = queue.front();
    queue.pop();
    if (llvm::isa<tf_device::ReturnOp>(op)) continue;
    ops_to_move.insert(op);
    for (Operation* user : op->getUsers()) {
      if (!ops_to_move.contains(user)) {
        queue.push(user);
      }
    }
  }
  return ops_to_move;
}

tf_device::LaunchOp CreateLaunchForBlock(OpBuilder* builder,