EXPECT_THAT(pre_calibration_result, IsOk());

  SmallVector<func::FuncOp> func_ops;
  for (auto func_op : pre_calibration_result->getOps<func::FuncOp>()) {
    func_ops.push_back(func_op);
  }
  ASSERT_THAT(func_ops, SizeIs(2));
  EXPECT_THAT(func_ops, Contains(HasSymName("main")));
  EXPECT_THAT(func_ops, Contains(HasSymName("composite_dot_general_fn_1")));

SmallVector<Value> GetAccessedResources(Operation& op) {
  SmallVector<Value, 4> accessed_resources;
  for (auto operand : op.getOperands()) {
    if (!IsResourceType(operand.getType())) continue;
    accessed_resources.push_back(operand);
  }
  return std::move(accessed_resources);
}

// Lifts the tail writes outside of tf_device.replicate. The written value is
// added to the values returned by tf_device.replicate op. Modify the assign

        t.flat<float>().setZero();
        outputs->push_back(t);
      } else if (output_name == "dense/kernel") {
        Tensor t =
            Tensor(tensorflow::DT_FLOAT, tensorflow::TensorShape({100, 50}));
        t.flat<float>().setZero();
        outputs->push_back(t);
      } else {
        // Create a scalar float tensor.

        auto dequantize_op = builder->create<TFL::DequantizeOp>(
            op->getLoc(), dequantized_input_type, input.get());
        dequantized_inputs.push_back(dequantize_op);
      } else {
        dequantized_inputs.push_back(input.get());
      }
    }

    // Result types.
    SmallVector<Type, 4> result_types;
    for (auto result_type : op->getResultTypes()) {

    worklist.pop();
    auto result = u.walk([&](SymbolUserOpInterface op) {
      if (llvm::isa<T, Types...>(op)) {
        if (!predicate || predicate(op)) {
          hits.push_back(op);
        } else {
          first_misses.push_back(op);
          return WalkResult::advance();
        }
      }
      llvm::SmallVector<func::FuncOp> callees;
      if (GetCallees(op, symtab, callees).failed()) {

    // each entry function. The one exception are initializer functions, which
    // have `tf_saved_model.initializer_type` instead.
    if (IsEntryFunction(func)) {
      entry_funcs.push_back(func);
    }
  });
  return entry_funcs;
}

LogicalResult GetCallees(SymbolUserOpInterface op, SymbolTable &symtab,
                         llvm::SmallVector<func::FuncOp> &callees) {

    if (std::fabs(rmax - rmin) < std::numeric_limits<double>::epsilon()) {
      scales.push_back(1.0);
      zeroPoints.push_back(qmin);
      continue;
    }

    double scale;
    int64_t nudgedZeroPoint;
    getNudgedScaleAndZeroPoint(qmin, qmax, rmin, rmax, scale, nudgedZeroPoint);
    scales.push_back(scale);
    zeroPoints.push_back(nudgedZeroPoint);
  }

    SmallVector<int64_t, 4> non_unit_dims;

    for (int i = 0; i < input_shape_extended.size(); i++) {
      int64_t dim = broadcast_shape[i];
      if (dim != 1) {
        non_unit_dims.push_back(dim);
        input_carryover_dims.push_back(input_shape_extended[i]);
      }
    }

    // If the reshape rank is less than the number of non-unit dimensions
    // of the broadcast, then the reshape collapses non-unit dimensions.

void InlineDeviceOp(tf_device::ClusterOp cluster_op) {
  auto& block = cluster_op.GetBody();

  llvm::SmallVector<Operation*, 4> non_terminator_ops;
  for (Operation& op : block.without_terminator()) {
    non_terminator_ops.push_back(&op);
  }
  for (auto op : non_terminator_ops) {
    op->moveBefore(cluster_op);
  }

  auto& return_op = cluster_op.GetBody().front();
  // This is the last op, should be tf_device::ReturnOp.

    if (context_.mode == RendererContext::kHeader) {
      absl::StrAppend(&text, argument.Initializer());
    }
    if (argument.HasDefaultValue()) {
      args_with_default_val.push_back(text);
    } else {
      args_without_default_val.push_back(text);
    }
  }
  std::vector<string> arguments;
  arguments.reserve(args_without_default_val.size() +
                    args_with_default_val.size());