llvm::SmallSet<int, 4> dynamic_arg_idx_set;
  if (dynamic_arg_idx) {
    for (auto idx : dynamic_arg_idx.getValue()) {
      dynamic_arg_idx_set.insert(mlir::dyn_cast<IntegerAttr>(idx).getInt());
    }
  }

  for (auto operand_type_and_idx : llvm::enumerate(op.getOperandTypes())) {
    Type operand_type = operand_type_and_idx.value();
    int index = operand_type_and_idx.index();

  }
  TF::SideEffectAnalysis side_effect_analysis(module);
  // Use a global path index across functions to make it easier to follow one
  // path for debugging purposes.
  int path_idx = 0;
  for (auto func : module.getOps<func::FuncOp>()) {
    if (func.isExternal()) continue;
    const auto& analysis_for_func =
        side_effect_analysis.GetAnalysisForFunc(func);
    CheckControlDependenciesForFunc(func, analysis_for_func, path_idx);

    const bool packed_input = partitioned_input.getIsPacked();
    int num_cores_per_replica = partitioned_input.getN();
    if (num_cores_per_replica_attr) {
      num_cores_per_replica = num_cores_per_replica_attr.getInt();
    } else if (packed_input) {
      return partitioned_input->emitOpError()
             << "num cores per replica unavailable";
    }

  llvm::SmallVector<tf_executor::IslandOp, 4> parallel_execute_op_islands;
  getOperation().walk([&](tf_executor::GraphOp graph_op) {
    for (auto island_op : graph_op.getOps<tf_executor::IslandOp>()) {
      if (!island_op.WrapsSingleOp()) {
        island_op.emitError(
            "tf_executor.island must perfectly wrap a single op");
        signalPassFailure();
      }

Status HandleInputOutputArraysWithModule(
    const toco::ModelFlags& model_flags,
    mlir::OwningOpRef<mlir::ModuleOp>* module) {
  mlir::func::FuncOp entry_function = nullptr;
  for (auto func : module->get().getOps<mlir::func::FuncOp>()) {
    if (auto tf_attrs =
            func->getAttrOfType<mlir::DictionaryAttr>("tf.entry_function")) {
      // TODO(b/184697652): There could be multiple entry functions. Let's

  // Apply transformation on each function. For recursive call case, another
  // function can be modified at the same time so avoid running functions in
  // parallel.
  for (auto func : module_op.getOps<func::FuncOp>()) {
    if (failed(applyPatternsAndFoldGreedily(func, frozen_patterns))) {
      func.emitError() << "quant-quantize-weights failed.";
      signalPassFailure();
    }
  }
}

}  // namespace

        final OsCpuObj osCpuObj = new OsCpuObj();
        osObj.cpu = osCpuObj;
        osCpuObj.percent = osProbe.getSystemCpuPercent();
        final OsStats osStats = osProbe.osStats();
        osObj.loadAverages = osStats.getCpu().getLoadAverage();
        return osObj;
    }

    private EngineObj getEngineObj() {
        final EngineObj engineObj = new EngineObj();
        try {

    ArrayRef<int64_t> int64_array);

// Returns the first operation with the given type in the function.
template <typename OpType>
OpType FindOperationOfType(func::FuncOp function) {
  for (auto op : function.getBody().getOps<OpType>()) {
    return op;
  }
  return nullptr;
}

// Returns the first user of the given operation, optionally of the given
// type if provided. If there is no user or user of type, return nullptr.

            function.getArgAttrOfType<mlir::IntegerAttr>(
                i, kResourceArgUniqueIdAttr)) {
      (*func_def.mutable_resource_arg_unique_id())[i] =
          resource_arg_unique_id_attr.getInt();
    }
  }

  return flib_def->AddFunctionDef(std::move(func_def));
}

Status Exporter::Convert(mlir::ModuleOp module,
                         const GraphExportConfig& configs,

            function.getArgAttrOfType<mlir::IntegerAttr>(
                i, kResourceArgUniqueIdAttr)) {
      (*func_def.mutable_resource_arg_unique_id())[i] =
          resource_arg_unique_id_attr.getInt();
    }
  }

  return flib_def->AddFunctionDef(std::move(func_def));
}

Status Exporter::Convert(mlir::ModuleOp module,
                         const GraphExportConfig& configs,