module attributes {tf_saved_model.semantics} {

  // Test case: Fail if some global tensor ops remain

 "tf_saved_model.global_tensor"() {sym_name = "v", type = tensor<f32>, value = dense<1.0> : tensor<f32> } : () -> ()
 "tf_saved_model.global_tensor"() {sym_name = "v2", type = tensor<f32>, value = dense<1.0> : tensor<f32> } : () -> ()

  func.func @f(%arg0: tensor<!tf_type.resource<tensor<f32>>> {tf_saved_model.bound_input = @v})

	my $funcname = "";
	if($sysname eq "") {
		$sysname = "SYS_$func";
		$sysname =~ s/([a-z])([A-Z])/${1}_$2/g;	# turn FooBar into Foo_Bar
		$sysname =~ y/a-z/A-Z/;
		if($libc) {
			$sysname =~ y/A-Z/a-z/;
			$sysname = substr $sysname, 4;
			$funcname = "libc_$sysname";
		}
	}
	if($libc) {
		if($funcname eq "") {
			$sysname = substr $sysname, 4;
			$sysname =~ y/A-Z/a-z/;

    "func.return"() : () -> ()
  }) {sym_name = "__inference_wrapped_function_4260250_0", sym_visibility = "private", tf._input_shapes = [#tf_type.shape<>], tf.signature.is_stateful, function_type = (tensor<i32>) -> ()} : () -> ()
  "func.func"() ({
  ^bb0(%arg0: tensor<i32>):
    "func.return"(%arg0) : (tensor<i32>) -> ()

  }
  return {};
}

TEST_F(ConvertAssetArgsTest, ConvertsSingleAssetArg) {
  OwningOpRef<ModuleOp> module_op = ParseModuleOpString(R"mlir(
    module {
      "tf_saved_model.asset"() {filename = "assets/file_0.txt", sym_name = "__tf_saved_model_asset0"} : () -> ()
      func.func @main(%arg_0: tensor<!tf_type.string> {tf_saved_model.bound_input = @__tf_saved_model_asset0}) -> () attributes {tf.entry_function = {inputs = "arg_0:0", outputs = ""}} {

	"sync"
	"syscall"
	"unsafe"
)

//go:linkname procUname libc_uname

var procUname uintptr

// utsname represents the fields of a struct utsname defined in <sys/utsname.h>.
type utsname struct {
	Sysname  [257]byte
	Nodename [257]byte
	Release  [257]byte
	Version  [257]byte
	Machine  [257]byte
}

// KernelVersion returns major and minor kernel version numbers

    module attributes {tf_saved_model.semantics} {
      "tf_saved_model.session_initializer"() <{initializers = []}> : () -> ()
      "tf_saved_model.asset"() <{filename = "assets/vocab_file.txt", sym_name = "__tf_saved_model_asset0_vocab_file.txt"}> : () -> ()

  // Create AssetOp; this holds the checkpoint_path.
  // TODO(b/318761632): Cleanup usage of string literals, instead use constants.
  auto asset_op = builder.create<tf_saved_model::AssetOp>(
      module->getLoc(),
      /*sym_name=*/
      builder.getStringAttr("__tf_saved_model_variables"),  // Val unimportant.
      /*filename=*/
      builder.getStringAttr(checkpoint_path));
  // Marks the input to be inlined.
  main_func.setArgAttr(

  bool IsInCompsiteFunction(Operation* op) {
    func::FuncOp parent = op->getParentOfType<func::FuncOp>();
    if (!parent) return false;

    StringRef sym_name = parent.getSymName();
    return sym_name.starts_with(kQuantizedFuncPrefix) ||
           sym_name.starts_with(kCompositeFuncPrefix);
  }

  ModuleOp module_;
  SymbolTable symbol_table_;
};

	Utime  uint32
	Stime  uint32
	Cutime uint32
	Cstime uint32
}

type Time_t int64

type Utimbuf struct {
	Actime  int64
	Modtime int64
}

type Utsname struct {
	Sysname  [16]byte
	Nodename [32]byte
	Release  [8]byte
	Version  [8]byte
	Machine  [16]byte
}

type Ucred struct {
	Pid int32
	Uid uint32
	Gid uint32
}

type RawSockaddrInet4 struct {
	Len    uint8

      /*inputs=*/{filename_input_type}, /*results=*/{});
  auto save_func = builder.create<func::FuncOp>(
      NameLoc::get(builder.getStringAttr(kTfQuantSaveFuncName)),
      /*sym_name=*/kTfQuantSaveFuncName, func_type);
  save_func.addEntryBlock();
  save_func.setPrivate();

  return save_func;
}

// Creates a save function that contains the `TF::SaveV2Op` for the variables in