LogicalResult matchAndRewrite(TF::PartitionedCallOp call_op,
                                PatternRewriter& rewriter) const override {
    const auto f_attr = mlir::dyn_cast<FlatSymbolRefAttr>(call_op.getFAttr());
    // removeAttr will return nullptr if no attribute was removed.
    if (!call_op->removeAttr(kQuantTraitAttrName) || !f_attr) {
      return failure();
    }

  // use it in exports or if there are breaking changes
  module->setAttr("tfl.schema_version",
                  builder.getI32IntegerAttr(model->version));
  if (!model->description.empty()) {
    module->setAttr("tfl.description",
                    builder.getStringAttr(model->description));
  }

  if (!metadata_attrs.empty()) {
    module->setAttr("tfl.metadata", builder.getDictionaryAttr(metadata_attrs));
  }

    func::FuncOp ResolveFunc(::mlir::SymbolTableCollection* table) {
      if (table)
        return table->lookupNearestSymbolFrom<func::FuncOp>(*this, getFAttr());
      return SymbolTable::lookupNearestSymbolFrom<func::FuncOp>(*this, getFAttr());
    }
    // TODO(b/204997177): Deprecate and remove.
    func::FuncOp func() {  return ResolveFunc(nullptr); }
  }];
}

			// doesn't automatically preclude some scenarios from happening.
			t.Parallel()

			if ignoreWatchCacheTests && tt.ignoreForWatchCache {
				t.Skip()
			}

			if tt.pred.GetAttrs == nil {
				tt.pred.GetAttrs = getAttrs
			}

			out := &example.PodList{}
			storageOpts := storage.ListOptions{
				ResourceVersion:      tt.rv,
				ResourceVersionMatch: tt.rvMatch,
				Predicate:            tt.pred,

           llvm::all_of(op->getResultTypes(), is_not_variant);
  };

  auto is_set_item_legal = [](Operation *op) {
    return op->hasAttr("resize_if_index_out_of_bounds") &&
           op->getAttr("resize_if_index_out_of_bounds")
               .cast<mlir::BoolAttr>()
               .getValue();
  };

  ConversionTarget target(*context);

  auto new_call = builder.create<CallOpType>(
      call_op.getLoc(),
      lifting_info.lifted_callee.getFunctionType().getResults(), new_operands,
      call_op->getAttrs());
  new_call->setAttr("f",
                    SymbolRefAttr::get(builder.getContext(),
                                       lifting_info.lifted_callee.getName()));
  AddLoadsStoresOutsideControlFlowOp(

	return syscall.Exec(argv0, argv, envv)
}

func Getag(path string) (ccsid uint16, flag uint16, err error) {
	var val [8]byte
	sz, err := Getxattr(path, "ccsid", val[:])
	if err != nil {
		return
	}
	ccsid = uint16(EncodeData(val[0:sz]))
	sz, err = Getxattr(path, "flags", val[:])
	if err != nil {
		return
	}
	flag = uint16(EncodeData(val[0:sz]) >> 15)
	return
}

// Mount begin

		watchTests: []*testWatchStruct{{basePod, false, ""}, {basePodAssigned, true, watch.Added}},
		pred: storage.SelectionPredicate{
			Label: labels.Everything(),
			Field: fields.ParseSelectorOrDie("spec.nodeName=bar"),
			GetAttrs: func(obj runtime.Object) (labels.Set, fields.Set, error) {
				pod := obj.(*example.Pod)
				return nil, fields.Set{"spec.nodeName": pod.Spec.NodeName}, nil
			},
		},
	}, {
		name:       "update",

      for (const auto& attr_name : attr_names) {
        if (!global_iter_id_op->hasAttr(attr_name)) continue;
        offset->setAttr(attr_name, global_iter_id_op->getAttr(attr_name));
        new_global_iter_id->setAttr(attr_name,
                                    global_iter_id_op->getAttr(attr_name));
      }
      // Make the next function to get inlined use a different offset.
      ++offset_value;
    }

	sz = int(r0)
	if int64(r0) == -1 {
		err = errnoErr2(e1, e2)
	}
	return
}

//go:nosplit
func get_FgetxattrAddr() *(func(fd int, attr string, dest []byte) (sz int, err error))

var Fgetxattr = enter_Fgetxattr

func enter_Fgetxattr(fd int, attr string, dest []byte) (sz int, err error) {
	funcref := get_FgetxattrAddr()
	if funcptrtest(GetZosLibVec()+SYS___FGETXATTR_A<<4, "") == 0 {
		*funcref = impl_Fgetxattr