if (value.IsBool()) {
        auto attr = value.AsBool();
        auto named_attr =
            builder.getNamedAttr(key, BuildVhloBooleanV1Attr(attr, builder));
        attributes.emplace_back(named_attr);
      }
      if (value.IsString()) {
        auto attr = value.AsString();
        auto named_attr = builder.getNamedAttr(
            key, BuildVhloStringV1Attr(attr.str(), builder));

    def attributes(Map<String, String> values) {
        def attrs = AttributeTestUtil.attributesFactory().mutable()
        attrs.attribute(ProjectInternal.STATUS_ATTRIBUTE, 'integration')
        if (values) {
            values.each { String key, String value ->
                attrs.attribute(Attribute.of(key, String), value)
            }
        }
        return attrs.asImmutable()
    }

    I32Attr:$num_tensor_list_or_flow_in
  );

  let results = (outs
     Variadic<TF_Tensor>:$result
  );

  let assemblyFormat = "`(`$max_iterations`,` $tensor_list_or_flow_in`,` $invariant_args `)` attr-dict `:` functional-type(operands, results)";
}

def TFAsyncWhileOp : TensorflowMlrt_Op<"tf_async_while", [Pure]> {
  let summary = "Asynchronously execution of while op for tf_mlrt";
  let description = [{

            override fun preVisitDirectory(dir: Path, attrs: BasicFileAttributes): FileVisitResult {
                return if (Files.isReadable(dir))
                    FileVisitResult.CONTINUE
                else
                    FileVisitResult.SKIP_SUBTREE
            }

            override fun visitFile(file: Path, attrs: BasicFileAttributes): FileVisitResult {

            getMetadata() >> configurationMetadata
            asVariant() >> variant
            getAttributes() >> attrs
        }
    }

    private VariantGraphResolveState defaultConfiguration(ImmutableAttributes attrs = attributes([:])) {
        return consumableConfiguration('default', attrs)
    }

    enum JavaVersion {
        JAVA5,
        JAVA6,
        JAVA7,
        JAVA8,
        JAVA9

                   "Ignored for MLIR input"),
    llvm::cl::Optional, llvm::cl::init("serve"));

// NOLINTNEXTLINE
opt<bool> elide_large_elements_attrs(
    "e",
    llvm::cl::desc(
        "Elide large elements attrs while dumping the output StableHLO."),
    llvm::cl::Optional, llvm::cl::init(false));

}  // namespace

namespace mlir {

namespace {
// Dump the ModuleOp 'module' to the file specified using 'outputFileName'

	return v.any.(LogValuer)
}

// Group returns v's value as a []Attr.
// It panics if v's [Kind] is not [KindGroup].
func (v Value) Group() []Attr {
	if sp, ok := v.any.(groupptr); ok {
		return unsafe.Slice((*Attr)(sp), v.num)
	}
	panic("Group: bad kind")
}

func (v Value) group() []Attr {
	return unsafe.Slice((*Attr)(v.any.(groupptr)), v.num)
}

//////////////// Other

}

func endpointStatusUpdateAttributes() admission.Attributes {
	attrs := endpointCreateAttributes()
	return admission.NewAttributesRecord(
		attrs.GetObject(), attrs.GetObject(), attrs.GetKind(), attrs.GetNamespace(), attrs.GetName(),
		attrs.GetResource(), "status", admission.Update, &metav1.UpdateOptions{}, false, nil)

        }
    }


    SmbFileHandleImpl openUnshared ( int flags, int access, int sharing, int attrs, int options ) throws CIFSException {
        return openUnshared(getUncPath(), flags, access, sharing, attrs, options);
    }


    SmbFileHandleImpl openUnshared ( String uncPath, int flags, int access, int sharing, int attrs, int options ) throws CIFSException {
        SmbFileHandleImpl fh = null;

  }

  SymbolTable symbol_table(op->getParentOfType<ModuleOp>());
  // Check the functions associated to CaseOp, IfOp and WhileOp.
  for (const NamedAttribute& attr : op->getAttrs()) {
    FlatSymbolRefAttr symbol_attr =
        dyn_cast_or_null<FlatSymbolRefAttr>(attr.getValue());
    if (!symbol_attr) continue;

    func::FuncOp target_func = dyn_cast_or_null<func::FuncOp>(
        symbol_table.lookup(symbol_attr.getValue()));