fused_lstm_func_.dump();

  // verify transpose
  EXPECT_EQ(
      fused_lstm_func_->getAttrOfType<StringAttr>(kTFImplements).getValue(),
      convert.GetCompositeOpName());
  EXPECT_EQ(fused_lstm_func_.getNumArguments(), 5);
  EXPECT_EQ(fused_lstm_func_.getFunctionType().getNumResults(), 1);

  auto transpose_op = fused_lstm_func_.getBody().front().begin();
  transpose_op++;

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

  }
  return false;
}

void ForEachArgConsumedByFallback(
    mlir::func::FuncOp func, llvm::function_ref<void(int arg_index)> action) {
  for (int arg_index = 0; arg_index < func.getNumArguments(); ++arg_index) {
    if (IsArgConsumedByFallback(func, arg_index)) action(arg_index);
  }
}

void ForEachArgConsumedByFallback(
    mlir::ModuleOp module,

    // right away, since they might weave through blocks, but we can replace
    // them with a dummy which DCE can pick up later.
    llvm::BitVector argsToErase(func.getNumArguments());
    for (int i = 0; i < func.getNumArguments(); i++) {
      if (auto global = tf_saved_model::LookupBoundInputOfType<
              tf_saved_model::GlobalTensorOp>(func, i, syms)) {
        OpBuilder builder(func.getBody());

    auto index_path = builder.getStringAttr(kTfSavedModelIndexPathAttr);
    module.walk([&](func::FuncOp func) {
      func->removeAttr(exported_names);
      for (unsigned i = 0, e = func.getNumArguments(); i != e; ++i) {
        if (func.getArgAttrOfType<FlatSymbolRefAttr>(i, bound_input)) {
          func.removeArgAttr(i, bound_input);
        }
        func.removeArgAttr(i, index_path);
      }

      func->getAttrs(),
      [](NamedAttribute namedAttr) { return ShouldStripAttr(namedAttr); }));
  for (auto namedAttr : stripAttrs) {
    func->removeAttr(namedAttr.getName());
  }

  for (int i = 0; i < func.getNumArguments(); ++i) {
    llvm::ArrayRef<mlir::NamedAttribute> attrs =
        mlir::function_interface_impl::getArgAttrs(func, i);
    auto stripAttrs = llvm::to_vector<4>(llvm::make_filter_range(
        attrs,

      func->getAttrs(),
      [](NamedAttribute namedAttr) { return ShouldStripAttr(namedAttr); }));
  for (auto namedAttr : stripAttrs) {
    func->removeAttr(namedAttr.getName());
  }

  for (int i = 0; i < func.getNumArguments(); ++i) {
    llvm::ArrayRef<mlir::NamedAttribute> attrs =
        mlir::function_interface_impl::getArgAttrs(func, i);
    auto stripAttrs = llvm::to_vector<4>(llvm::make_filter_range(
        attrs,

                builder.getStrArrayAttr({name}));

  builder.setInsertionPointToStart(init.addEntryBlock());

  for (func::FuncOp func : tf_saved_model::GetInitializerFunctions(module)) {
    if (func.getNumArguments() != 0) {
      session_initializer->emitWarning(
          "encountered session initializers with arguments");
      continue;
    }

    // Since we're now calling this function, savedmodel verification

    llvm::BitVector unused_args(func.getNumArguments());
    llvm::BitVector unused_results(func.getNumResults());
    llvm::DenseMap<int, int> return_to_operand;
    llvm::BitVector invariant_returns =
        GetInvariantReturns(region, func.getNumResults());
    llvm::DenseMap<Value, int> argument_to_index;
    std::vector<int> use_count(func.getNumArguments(), 0);

  // passing the platform index.
  FunctionType function_type = func_op.getFunctionType();
  ArrayRef<Type> new_input_types =
      function_type.getInputs().take_back(func_op.getNumArguments() - 1);
  func_op.setFunctionType(
      FunctionType::get(ctx, new_input_types, function_type.getResults()));
  func_op.getBody().eraseArgument(0);
}

}  // namespace