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 &&
            remaining_incoming_ctrl_edges[user] == 0) {

// before or above the parallel_execute.
TF::AssignVariableOp GetSingleUseResourceWrite(
    tf_device::ParallelExecuteOp parallel_execute, Value result) {
  if (!result.hasOneUse()) return nullptr;

  OpOperand& use = *result.getUses().begin();
  auto assign_var = dyn_cast<TF::AssignVariableOp>(use.getOwner());
  if (!assign_var) return nullptr;

  if (use.get() != assign_var.getValue()) return nullptr;

    for (auto m : fqOp.getMax())
      max.push_back(cast<FloatAttr>(m).getValueAsDouble());

    return fakeQuantAttrsToType(fqOp.getLoc(), fqOp.getNumBits(),
                                fqOp.getAxis(), min, max, fqOp.getNarrowRange(),
                                expressedType, fqOp.getIsSigned());
  }
};

void ConvertSimulatedQuantPass::runOnOperation() {
  bool hadFailure = false;

    Value res = read.getResource();
    Operation* scope = res.getParentBlock()->getParentOp();
    if (!scope->isProperAncestor(replicate)) continue;
    bool has_conflicting_write = false;
    for (OpOperand& use : res.getUses()) {
      Operation* using_op = use.getOwner();
      if (using_op == read) continue;
      if (!replicate->isProperAncestor(using_op)) continue;
      Operation* peer = GetAncestorBelow(using_op, replicate);

// multiple such activations, one is returned (with no guarantee as to which
// one). If there are no activation functions that use the output, returns
// nullptr.
Operation *GetActivation(Value op) {
  for (auto &use : op.getUses()) {
    if (IsActivationFunction(use.getOwner())) return use.getOwner();
  }
  return nullptr;
}

// Finds and returns a BiasAdd that uses the result of `op` as the `value`

    llvm::SmallVector<Operation*> users(op->getUsers().begin(),
                                        op->getUsers().end());

    bool changed = false;
    for (auto& use : op->getUses()) {
      Operation* user_op = use.getOwner();
      int user_idx = use.getOperandNumber();
      if (!IsOpWithInt8TypeOperand(user_op)) continue;
      // If the next op is terminator, function type needs to be changed so

      });
    }
    // For dynamic case, the result of conv should be used by shape_of and mul.
    if (is_dynamic_broadcast) {
      auto conv_uses = (*conv_op.getODSResults(0).begin()).getUses();
      if (std::distance(conv_uses.begin(), conv_uses.end()) != 2 ||
          quant::FindUserOfType<shape::ShapeOfOp>(conv_op) == nullptr ||
          quant::FindUserOfType<mhlo::MulOp>(conv_op) == nullptr) {

  for (const auto& p : llvm::zip(live_outs, launch_op.getResults())) {
    Value from = std::get<0>(p);
    // TODO(jingpu): move this to RegionUtils.h in MLIR core.
    for (auto& use : llvm::make_early_inc_range(from.getUses())) {
      if (launch_op_region->isAncestor(use.getOwner()->getParentRegion()))
        continue;
      use.set(std::get<1>(p));
    }
  }
}

// Get all escaped live-out values of a region.

           mlir::isa<IntegerType>(key_dtype) &&
           mlir::cast<IntegerType>(key_dtype).getWidth() == 64))) {
      return false;
    }

    for (auto& use : hashtable->getUses()) {
      Operation* user = use.getOwner();

      // Allow consuming hash table ops that can be covered by TensorFlow Lite
      // hash table kernels.

  }

  // All results in our set that have a user outside our set.
  llvm::DenseSet<Value> outputs_seen;
  for (Operation* op : ops) {
    for (Value result : op->getResults()) {
      for (auto& use : result.getUses()) {
        if (!all_operations.contains(use.getOwner())) {
          if (!outputs_seen.contains(result)) {
            outputs->push_back(result);
            outputs_seen.insert(result);
          }