return unmanagedInstanceOf(modelReference, new Transformer<T, MutableModelNode>() {
            @Override
            public T transform(MutableModelNode modelNode) {
                T t = factory.create();
                initializer.execute(modelNode);
                return t;
            }
        });
    }

            // Destructuring declarations use their initializer.
            is KtDestructuringDeclaration ->
                parent.initializer == child

            // Backing field declarations use their initializer.
            is KtBackingField ->
                parent.initializer == child

            // Property accessors can use their bodies if not blocks.

# CHECK-SAME: bad_consumers
# CHECK-SAME: min_consumer
# CHECK-SAME: producer

# CHECK: "tf_saved_model.global_tensor"()
# CHECK: "tf_saved_model.session_initializer"() <{initializers = [@[[INIT_FUNC:[a-zA-Z_0-9]+]]]}> : () -> ()

# Initializer function. This should contain the initialization sequence for the
# variable.

		var _, x = mymap["a"]
		println(x)
	}
	innerTest()
}

var Test2 = func() {
	// The following initializer should not be part of init()
	// The compiler used to generate a call to Panic() in init().
	var _, x = Panic()
	_ = x
}

func Panic() (int, int) {
	panic("omg")
	return 1, 2
}

        GFileUtils.mkdirs(cacheDir);
        InMemoryCache cache = new InMemoryCache(cacheDir, displayName, cacheCleanupStrategy != null ? cacheCleanupStrategy.getCleanupAction() : null);
        if (initializer != null) {
            initializer.accept(cache);
        }
        return cache;
    }

}

def ConvertSessionInitializerToFunctionPass : Pass<"tf-saved-model-convert-session-initializer-to-function", "ModuleOp"> {
  let summary = "Converts the session initializer to a function.";
  let description = [{
      This converts
        "tf_saved_model.session_initializer"() {initializers = [@a, @b, @c]} : () -> ()
      to
	func.func @session_initializer() {
	  call @a() : () -> ()

  let summary = "Initializes TensorFlow session state.";
  let description = [{
    The session initializer op marks one or more functions that must be called
    by an external agent exactly once to initialize TensorFlow session state,
    and this must happen before any other exported functions are called. There
    must be no more than one session initializer op in a saved model.

	r := make([]T2, len(s))
	for i, v := range s {
		r[i] = f(v)
	}
	return r
}

// Reduce reduces a []T1 to a single value using a reduction function.
func Reduce[T1, T2 any](s []T1, initializer T2, f func(T2, T1) T2) T2 {
	r := initializer
	for _, v := range s {
		r = f(r, v)
	}
	return r
}

// Filter filters values from a slice using a filter function.
func Filter[T any](s []T, f func(T) bool) []T {
	var r []T

    /**
     * Specifies an action to execute to initialize the cache contents, if the cache does not exist or is invalid. An exclusive lock is held while the initializer is executing, to prevent
     * cross-process access.
     */
    CacheBuilder withInitializer(Consumer<? super PersistentCache> initializer);

    /**

  // No initializer function matches the initializer type.
  EXPECT_THAT(init_func_op, IsNull());
}

TEST_F(TfSavedModelTest, GetInitializerFunctionsEmptyWhenNoInitFunctions) {
  constexpr StringRef kModuleOpStr = R"mlir(
    module attributes {tf_saved_model.semantics} {
      "tf_saved_model.session_initializer"() {initializers = []} : () -> ()
    }
  )mlir";

  Block block;