}
      if (!common_arg_index.has_value()) {
        common_arg_index = block_arg.getArgNumber();
      } else if (common_arg_index.value() != block_arg.getArgNumber()) {
        return op->emitError("result #")
               << result_idx
               << " is not tied to the same argument across all branches";
      }
    }

    if (io_match && result_idx != common_arg_index.value()) {

    return IsControlFlowV1Op(op) ? mlir::WalkResult::interrupt()
                                 : mlir::WalkResult::advance();
  });
  if (result.wasInterrupted()) {
    mlir::TFL::AttachErrorCode(
        module.emitError(
            "The graph has Control Flow V1 ops. TFLite converter doesn't "
            "support Control Flow V1 ops. Consider using Control Flow V2 ops "

        auto error_msg =
            "'main' FuncOp in XlaCallModuleOp missing or has visibility other "
            "than 'public'";
        if (main_func_op) {
          main_func_op->emitError(error_msg);
        }
        return rewriter.notifyMatchFailure(op, error_msg);
      }
    }
    Builder stablehlo_builder(stablehlo_module_op.get().getContext());

  FrozenRewritePatternSet frozen_patterns(std::move(patterns));

  for (auto func : module_op.getOps<func::FuncOp>()) {
    if (failed(applyPatternsAndFoldGreedily(func, frozen_patterns))) {
      func.emitError() << "quant-preprocess-op failed.";
      signalPassFailure();
    }
  }
}

}  // namespace

// Creates an instance of the TensorFlow dialect PreprocessOp
// pass.

  bool found_path = FindPathBfs(source_op, target_op, path);
  if (!found_path) {
    // This shouldn't happen, returning an error instead of asserting so it
    // doesn't go unnoticed if it ever happens.
    target_op.emitError("no path to target op found, cannot emit warnings");
    return;
  }

  // Emit warnings for path.
  int node_idx = 0;
  for (auto iter = path.rbegin(); iter != path.rend(); ++iter) {

  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();
      }

      if (isa<tf_device::ParallelExecuteOp>(&island_op.GetBody().front()))

          /*is_signed=*/true,
          /*narrow_range=*/true, /*legacy_float_scale=*/false);
    }

    auto quant_type = dyn_cast<quant::QuantizedType>(weight_type);
    if (!quant_type) {
      op->emitError(
          "Failed to get weight quantization parameters for weight-only "
          "quantization.");
      return;
    }

    const Type expressed_type = op->getResult(0).getType();

  for (auto func : module_op.getOps<func::FuncOp>()) {
    removeAllStatsOp(func);
    if (failed(applyPatternsAndFoldGreedily(func, frozen_patterns))) {
      func.emitError() << "quant-prepare-quantize-drq failed.";
      signalPassFailure();
    }
  }
}

}  // namespace

// Creates an instance of the TensorFlow dialect PrepareQuantizeDRQ
// pass.

  // - Converting XlaGatherOp to SliceOp
  RewritePatternSet patterns(ctx);
  populateWithGenerated(patterns);

  if (failed(applyPatternsAndFoldGreedily(func, std::move(patterns)))) {
    func.emitError() << "quant-converting-tf-xla-op-to-tf-op failed.";
    signalPassFailure();
  }
}

}  // namespace

std::unique_ptr<OperationPass<func::FuncOp>> CreateConvertTfXlaOpToTfOpPass() {

}  // namespace

void MergeSaveFunctionOpsToMainPass::runOnOperation() {
  ModuleOp module_op = getOperation();

  func::FuncOp main_func_op = GetMainFunction(module_op);
  if (!main_func_op) {
    module_op.emitError("Main function op not found.");
    return signalPassFailure();
  }

  func::FuncOp save_func_op = GetSaveFuncOp(module_op);
  if (!save_func_op) return;