.getOperation();
  MLIRContext* context = launch_op.getContext();
  op->removeAttr(StringAttr::get(context, kDeviceAttr));
  op->moveBefore(return_op);
}

void DeviceAttributeToLaunch::runOnOperation() {
  const Dialect* tf_dialect = getContext().getLoadedDialect("tf");

  getOperation().walk([&](Operation* op) {

  }
  inline TFL::ConstBytesAttr CustomOption(OpBuilder* builder,
                                          const std::string& content) {
    return TFL::ConstBytesAttr::get(builder->getContext(),
                                    StringRef(content.data(), content.size()));
  }

  std::vector<int64_t> FlatbufferVecToMlirVec(const flexbuffers::Vector& vec) {
    std::vector<int64_t> temp(vec.size(), 0);

// license that can be found in the LICENSE file.

//go:build !compiler_bootstrap

package main

import (
	"go/ast"
	"go/token"
)

func (f *File) walkUnexpected(x interface{}, context astContext, visit func(*File, interface{}, astContext)) {
	switch n := x.(type) {
	default:
		error_(token.NoPos, "unexpected type %T in walk", x)
		panic("unexpected type")

	case *ast.IndexListExpr:
		f.walk(&n.X, ctxExpr, visit)

    if (!status.ok()) {
      VLOG(1) << "Shape inference failed for node " << n->name() << ": "
              << status;
    } else {
      shape_inference::InferenceContext* context = shape_refiner->GetContext(n);
      for (int i = 0; i < n->num_outputs(); i++) {
        shape_inference::ShapeHandle handle = context->output(i);
        VLOG(4) << "Output " << i << " for node " << n->name() << ": "

func::FuncOp CreateSessionInitFunc(ModuleOp module) {
  constexpr char kSessionInitFuncName[] = "SessionInitializerFunction";

  mlir::OpBuilder builder(module.getBodyRegion());
  auto func_type =
      FunctionType::get(module.getContext(), /*inputs=*/{}, /*results=*/{});
  auto func = builder.create<func::FuncOp>(module->getLoc(),
                                           kSessionInitFuncName, func_type);
  func->setAttr(kTfSavedModelExportedNamesAttr,

  // `tf.Const`->`tf.Cast` patterns after variable freezing. The TF shape
  // inference pass is also required to resolve unknown shapes in the TF dialect
  // after variable freezing.
  mlir::PassManager pm(module_op.getContext());
  pm.addPass(mlir::TF::CreateTFShapeInferencePass());
  mlir::odml::AddLegalizeTFToStablehloPasses(pm, /*skip_quantization_ops=*/true,
                                             /*skip_resize=*/false,

			ctx: genericapirequest.NewContext(),
			obj: &certapi.CertificateSigningRequest{},
			expectedObj: &certapi.CertificateSigningRequest{
				Status: certapi.CertificateSigningRequestStatus{Conditions: []certapi.CertificateSigningRequestCondition{}},
			},
		},
		"user in context, no user in obj": {
			ctx: genericapirequest.WithUser(
				genericapirequest.NewContext(),
				&user.DefaultInfo{
					Name:   "bob",

      Class<? super @NonNull E> type, E[] emptyArrayForContents, Iterable<? extends E> contents) {
    List<E> setContents = new ArrayList<>();
    for (E e : contents) {
      if (!setContents.contains(e)) {
        setContents.add(e);
      }
    }
    return new MinimalSet<>(type, setContents.toArray(emptyArrayForContents));
  }

  private MinimalSet(Class<? super @NonNull E> type, E... contents) {

      Class<? super @NonNull E> type, E[] emptyArrayForContents, Iterable<? extends E> contents) {
    List<E> setContents = new ArrayList<>();
    for (E e : contents) {
      if (!setContents.contains(e)) {
        setContents.add(e);
      }
    }
    return new MinimalSet<>(type, setContents.toArray(emptyArrayForContents));
  }

  private MinimalSet(Class<? super @NonNull E> type, E... contents) {

        q_op, q_op.getResult().getType(), q_op.getArg());
    return success();
  }
};

void PostQuantizePass::runOnOperation() {
  RewritePatternSet patterns(&getContext());
  func::FuncOp func = getOperation();
  MLIRContext* ctx = func.getContext();
  // TODO: b/307463853 - Consider splitting passes for each pattern set.
  patterns.add<FoldTrivalRequantizeOp<quantfork::QuantizeCastOp>,