auto launch = builder->create<mlir::tf_device::LaunchOp>(
      op->getLoc(), builder->getStringAttr(host_device), launch_result_types);
  launch.getBody().push_back(launch_block);

  builder->setInsertionPointToEnd(&launch.GetBody());
  builder->create<mlir::tf_device::ReturnOp>(op->getLoc(), launch_results);

  return launch;
}

// Checks if an operation is a supported TPU embedding op.

  auto island = builder.create<IslandOp>(
      sub_op->getLoc(), sub_op->getResultTypes(), control_type, control_inputs);
  island.getBody().push_back(new Block);
  Block* block = &island.getBody().back();
  builder.setInsertionPointToEnd(block);
  sub_op->replaceAllUsesWith(island.getOutputs());
  sub_op->moveBefore(block, block->begin());
  builder.create<YieldOp>(sub_op->getLoc(), sub_op->getResults());
  return island;
}

            builder.create<SparseQConstOp>(op->getLoc(), cst.getQtypeAttr(),
                                           cst.getValue(), s_param, new_value);
        value.replaceAllUsesWith(s_qconst.getResult());
        cst.erase();
      }

      if (result.needs_densify) {
        auto value = op->getOperand(operand);
        auto densify =
            builder.create<DensifyOp>(op->getLoc(), value.getType(), value);

  for (int64_t dim : element_shape) {
    buffer_shape.push_back(dim);
  }
  auto zero = CreateScalarConst(0, builder, op->getLoc());
  if (getElementTypeOrSelf(zero.getType()) != element_dtype) {
    zero = builder.create<TF::CastOp>(
        op->getLoc(),
        ArrayRef<Type>{tensorflow::GetTypeFromTFTensorShape({}, element_dtype)},
        ArrayRef<Value>{zero});
  }
  auto buffer_type =

    // It is currently not possible to easily pack the output of a multi-result
    // op into an op with a single varidic output in `.td`.
    auto converted = rewriter.create<TFL::CustomOp>(
        op->getLoc(), op->getResultTypes(), op->getOperands(),
        "TensorListPopBack", TFL::ConstBytesAttr::get(getContext(), ""));
    rewriter.replaceOp(op, converted.getResults());
    return success();
  }
};

    "$_builder.create<TF::ShapeOp>($0.getLoc(), $1, $2)">;

def IsI32 : NativeCodeCall<
    "$_builder.getBoolAttr(getElementTypeOrSelf($0.getType()).isInteger(32))">;

def CreateTFCastOpF32 : NativeCodeCall<
    "CreateTFCastOpF32(&$_builder, $0.getLoc(), $1, $2)">;

def CreateTFCastOpI32 : NativeCodeCall<
    "CreateTFCastOpI32(&$_builder, $0.getLoc(), $1, $2)">;

def CreateTensorScatterNdOp : NativeCodeCall<

                          op.getLoc(), &rewriter);
  } else if (out_reshape_need) {
    out = createOutputReshapeOpForDynamic(out, reshape_shape, original_lhs,
                                          original_rhs, original_dnums,
                                          op.getLoc(), &rewriter);
  }
  out = createTransposeOp(out, op.getLoc(), out_transpose, &rewriter);

  rewriter.replaceOp(op, out);

    for (const auto& arg : func_op.getArguments()) {
      arg_locs.push_back(arg.getLoc());
    }
  }

  // Creates a new main function.
  auto func_type = FunctionType::get(context, arg_types, result_types);
  auto main_func = builder.create<func::FuncOp>(
      module_op.getLoc(), kImportModelDefaultGraphFuncName, func_type);
  builder.createBlock(&main_func.getBody(), main_func.begin(), arg_types,

              operand.getDefiningOp<corert::ConstDenseTensorOp>()) {
        new_values.push_back(
            rewriter.create<fallback_async::ConstDenseTensorOp>(
                op.getLoc(), rewriter.getType<fallback::TFTensorType>(),
                corert_const_dense_tensor_op.getValue()));
        should_rewrite = true;
        continue;
      }
      if (auto corert_const_string_tensor_op =

    }
  }
  auto island = OpBuilder(fetch).create<IslandOp>(
      fetch.getLoc(), data_types,
      /*control=*/ControlType::get(fetch.getContext()),
      /*controlInputs=*/control_fetches);
  island.getBody().push_back(new Block);
  OpBuilder::atBlockEnd(&island.GetBody())
      .create<YieldOp>(fetch.getLoc(), data_fetches);
  const int fetch_control_idx = data_fetches.size();