for (auto func_op : module_op.getOps<func::FuncOp>()) {
    if (failed(LiftHashTableOpsToArguments(module_op, func_op))) {
      signalPassFailure();
      return;
    }
  }
}

static PassRegistration<LiftHashTableOpsAsArgsPass> pass;

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>> CreateLiftHashTableOpsAsArgsPass() {
  return std::make_unique<LiftHashTableOpsAsArgsPass>();
}

  }

  auto it = function_library_map.find(op_set);
  if (it != function_library_map.end()) {
    return it->second;
  }
  return llvm::StringRef();
}

static PassRegistration<InsertQuantizedFunctionsPass> pass;

void InsertQuantizedFunctionsPass::runOnOperation() {
  ModuleOp module = getOperation();
  SymbolTable symbol_table(module);

    LOG(INFO) << "There are no VarHandleOps to restore. RestoreV2 op will not "
                 "be created.";
    return;
  }

  CreateRestoreV2Op(target_var_handle_ops, session_init_func);
}

static PassRegistration<InsertRestoreOpPass> pass{};

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>> CreateInsertRestoreOpPass() {
  return std::make_unique<InsertRestoreOpPass>();
}

}  // namespace quant

  }
}
}  // namespace

std::unique_ptr<OperationPass<func::FuncOp>> CreatePinOpsWithSideEffectsPass() {
  return std::make_unique<PinOpsWithSideEffectsPass>();
}

static PassRegistration<PinOpsWithSideEffectsPass> pass;

}  // namespace TFL

    LOG(INFO) << "There are no VarHandleOps to save. SaveV2 op will not "
                 "be created.";
    return;
  }

  CreateSaveFunc(module_op, target_var_handle_ops);
}

static PassRegistration<InsertSaveOpPass> pass{};

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>> CreateInsertSaveOpPass() {
  return std::make_unique<InsertSaveOpPass>();
}

}  // namespace quant

}
}  // namespace

std::unique_ptr<OperationPass<func::FuncOp>> CreateOptimizeBatchMatmulPass() {
  return std::make_unique<OptimizeBatchMatmulPass>();
}

static PassRegistration<OptimizeBatchMatmulPass> pass;

}  // namespace TFL