// Updates function return type of the given functions to match the terminator
// op operands' types.
//
// Requires the function has exactly one block.
void UpdateFuncType(func::FuncOp func) {
  Operation* terminator = func.front().getTerminator();
  auto return_types = llvm::to_vector<4>(terminator->getOperandTypes());

  FunctionType func_type = func.getFunctionType();
  if (llvm::ArrayRef(return_types) == func_type.getResults()) return;

  }

  // Replace original terminator with new terminator for returning merged
  // execute results.
  Operation* old_terminator = execute_region->front().getTerminator();
  builder->setInsertionPointToEnd(&execute_region->front());
  builder->create<tf_device::ReturnOp>(old_terminator->getLoc(),
                                       merged_execute_launch.getResults());
  old_terminator->erase();

                   mlir::TF::TensorArrayWriteV3Op>(op);
}

static bool FunctionContainsOnlyNoSideEffectOpOrTensorArrayOp(
    mlir::func::FuncOp func_op) {
  for (mlir::Operation& op : func_op.front()) {
    if (!mlir::isMemoryEffectFree(&op) && !IsTensorArrayOp(&op)) return false;
  }

  return true;
}

TensorArraySideEffectAnalysis::TensorArraySideEffectAnalysis(
    mlir::ModuleOp module) {

        std::get<0>(result).replaceAllUsesWith(std::get<1>(result));
      }

      rewriter.setInsertionPoint(cloned_func.getBody().front().getTerminator());
      rewriter.create<TF::_XlaSendFromHostOp>(
          func.getLoc(),
          cloned_func.getBody().front().getTerminator()->getOperands(),
          /*dynamic_key=*/dynamic_key, op.getRecvKeyAttr(),
          /*device_ordinal=*/rewriter.getI64IntegerAttr(0),

  // body and removes the arguments.
  void RewriteFunction(const SymbolTable& symbol_table, func::FuncOp func) {
    if (func.getNumArguments() == 0) {
      return;
    }

    auto builder = OpBuilder::atBlockBegin(&func.front());

    llvm::SmallDenseMap<llvm::StringRef, TF::ConstOp> const_ops;
    llvm::BitVector arg_indexes_to_remove(func.getNumArguments());

    // Replace arguments with const ops.

  }
  void runOnOperation() override {
    const auto& cost_analysis = getAnalysis<CostAnalysis>();

    auto func_op = getOperation();
    for (auto& op : func_op.front()) {
      op.emitRemark() << "Cost: " << cost_analysis.GetCost(&op);
    }
  }
};

static mlir::PassRegistration<TestCostAnalysis> pass;

}  // namespace tfrt_compiler

func defaultGODEBUG(p *Package, directives, testDirectives, xtestDirectives []build.Directive) string {
	if p.Name != "main" {
		return ""
	}
	goVersion := modload.MainModules.GoVersion()
	if modload.RootMode == modload.NoRoot && p.Module != nil {
		// This is go install pkg@version or go run pkg@version.
		// Use the Go version from the package.
		// If there isn't one, then assume Go 1.20,
		// the last version before GODEBUGs were introduced.

    }
  }
}

// Get all escaped live-out values of a region.
void GetLiveOuts(Region* region, llvm::SmallVectorImpl<Value>* live_outs) {
  live_outs->clear();

  for (Operation& op : region->front()) {
    for (Value v : op.getResults()) {
      // A value is live-out if any of its users are not inside value producer's
      // region.
      bool is_live_out = llvm::any_of(v.getUsers(), [&](Operation* user) {

// %5 = select(%2, %3, %4)
// return %1, %5
LogicalResult MatchReduceToArgMinMaxType2(mhlo::ReduceOp reduce_op,
                                          bool is_argmax) {
  Block& body = reduce_op.getBody().front();
  if (body.getNumArguments() != 4) return failure();

  mhlo::ReturnOp return_op = dyn_cast<mhlo::ReturnOp>(body.back());
  if (!return_op || return_op.getNumOperands() != 2) return failure();

    func::FuncOp func, llvm::SmallVectorImpl<Type>& new_input_types,
    OpBuilder builder) {
  if (mlir::isa<FloatType>(input_type)) {
    return success();
  }

  Block& block = func.front();
  builder.setInsertionPointToStart(&block);

  for (int i = 0; i != block.getNumArguments(); ++i) {
    Value arg = block.getArgument(0);
    Type arg_type = arg.getType();
    Value new_arg = arg;