}
  return success();
}

void SplitMergedOperandsPass::runOnOperation() {
  llvm::DenseSet<Value> stateful_values;
  auto func = getOperation();
  OpBuilder builder(func);
  for (auto& bb : func.getBody()) {
    for (auto& op : bb) {
      if (failed(DuplicateValueIfNeeded(&op, &stateful_values, &builder))) {
        func.emitError() << "Failed to duplicate values for the stateful op\n";
        return signalPassFailure();

 public:
  explicit ConvertLSTMCellSimpleToFusedLSTM(mlir::func::FuncOp fused_func_op)
      : fused_func_op_(fused_func_op),
        couple_input_forget_gates_(false),
        builder_(fused_func_op.getBody()) {}

  // not copyable.
  ConvertLSTMCellSimpleToFusedLSTM(const ConvertLSTMCellSimpleToFusedLSTM&) =
      delete;
  ConvertLSTMCellSimpleToFusedLSTM& operator=(
      const ConvertLSTMCellSimpleToFusedLSTM&) = delete;

    mlir::func::FuncOp func, int& counter,
    llvm::SmallDenseSet<StringRef>& dialects, Operation* module) {
  // don't re-process functions we generated
  if (func->getAttr("dialect")) return;
  processRegion(func.getBody(), counter, dialects, module);
}

void GroupByDialectPass::processRegion(mlir::Region& region, int& counter,
                                       llvm::SmallDenseSet<StringRef>& dialects,

  func.setType(updated_type);
}

// TODO(jpienaar): Remove when recursive side-effect modeling is added.
bool IsSideEffectFree(func::FuncOp func) {
  return !func.getBody()
              .walk([&](Operation* op) {
                if (!isMemoryEffectFree(op) &&
                    !op->hasTrait<OpTrait::IsTerminator>())
                  return WalkResult::interrupt();

class FuncOp:
    def __init__(self, *args, **kwargs) -> None: ...
    def create(self, arg0: str, arg1: FunctionType) -> FuncOp: ...
    def getArguments(self) -> list[BlockArgument]: ...
    def getBody(self) -> Region: ...
    def getName(self) -> str: ...
    def getType(self) -> FunctionType: ...

class FunctionType(Type):
    def __init__(self, *args, **kwargs) -> None: ...
    def getResults(self) -> list[Type]: ...

    if (!symbol_attr) continue;

    func::FuncOp target_func = dyn_cast_or_null<func::FuncOp>(
        symbol_table.lookup(symbol_attr.getValue()));
    if (!target_func) continue;

    if (!target_func.getBody()
             .getOps<TF::CalibrationStatisticsSaverOp>()
             .empty()) {
      return true;
    }
  }
  return false;
}

}  // namespace

  if (shared_name.empty()) return false;

  for (func::FuncOp init_func_op :
       tf_saved_model::GetInitializerFunctions(module_op)) {
    for (Operation& op : init_func_op.getBody().getOps()) {
      StringRef other_shared_name = GetSharedName(&op);
      if (IsHashTableOp(&op) && other_shared_name == shared_name) {
        return true;
      }
    }
  }
  return false;
}

	if err != nil {
		panic(err)
	}
	return req
}

func dummyRequestWithBodyNoGetBody(method string) *Request {
	req := dummyRequestWithBody(method)
	req.GetBody = nil
	return req
}

// issue22091Error acts like a golang.org/x/net/http2.ErrNoCachedConn.
type issue22091Error struct{}

func (issue22091Error) IsHTTP2NoCachedConnError() {}

  subgraphs_metadata.reserve(funcs.size());
  for (auto& func : funcs) {
    subgraphs_metadata.push_back(
        CreateSubgraphMetadata(hardware_map, &func.getBody(), &fb_builder));
  }
  auto runtime_metadata =
      CreateRuntimeMetadata(fb_builder, hardware_metadata_offset,
                            fb_builder.CreateVector(subgraphs_metadata));

    // then tensor<1xf32> is the subtype.
    tensor_types.emplace_back(var_handle_op.resource_subtype());
  }

  auto builder =
      OpBuilder::atBlockTerminator(&session_init_func.getBody().front());

  const BlockArgument filename_arg =
      InsertFilePrefixArgument(session_init_func, builder);

  TF::ConstOp tensor_names_const =
      CreateTensorNamesConst(tensor_names, builder);