public final class MainKt {
    // source: 'main.kt'
    public final static method PostCardSimple(p0: kotlin.jvm.functions.Function1, p1: boolean, p2: kotlin.jvm.functions.Function0): void

std::unique_ptr<OperationPass<func::FuncOp>>
CreateInsertCustomAggregationOpsPass(
    const ::stablehlo::quantization::CalibrationOptions& calib_opts);

// Replaces composite functions with quantized composite functions. After this
// pass runs, functions in the given graph will be replaced with their quantized
// versions. By doing so, the quantization will be applied to the given input.

  }
  return bytecode;
}

// Serializes the stablehlo functions called by XlaCallModuleOp to bytecode
// and embeds the bytecode in XlaCallModuleOp's `module` attribute.
//
// The stablehlo functions include the function referred by XlaCallModuleOp's
// `_entry_function` attribute, and any stablehlo functions called transitively
// from the entry function.

      context, bundle.saved_object_graph(), &revived_objects));

  // Revive function library functions as concrete functions without captures.
  // This is necessary because object graph functions may refer to functions
  // _not_ in the object graph: A while loop, for example, will create two
  // auxiliary `while_cond` and `while_body` functions that are only present in
  // the graph def function library.
  for (const FunctionDef& function :

#include "${functionName}.h"

// Include functions from dependencies
<% projectDeps.each { p ->
  sourceFiles.times { %>
#include "${p}lib${it + 1}.h"
<%
  }
} %>

<% functionCount.times { %>
long CPP_${functionName}_${it + 1} () {
  long sum = 1;
  // Call functions defined in dependent projects.
  <% projectDeps.each { p ->
    sourceFiles.times {
      def functionName = "${p}lib${it + 1}"
      functionCount.times {
  %>

      GetInitFuncOps(module_op);
  if (failed(init_func_ops)) {
    module_op->emitError("Validation on initializer functions failed.");
    return signalPassFailure();
  } else if (init_func_ops->empty()) {
    VLOG(1) << "No initializer functions found.";
    return;
  }

  // Find the initializer functions and clone their ops to @main.
  for (const StringRef init_type : kInitializerTypesByMergeOrder) {

    ifConversionSupported {
        registerObjectConversionComponent(component)
    }
}


/**
 * Introduces functions for registering dependencies, such as `implementation(...)`, as member functions of
 * types with getters returning [DependencyCollector] in the schema.
 * Resolves such functions at runtime, if used with object conversion.
 */
private

  return std::move(*loader).module();
}

// Renames functions in the stablehlo module to avoid naming conflicts with
// existing functions in the tf module.
// Sets _from_xla_call_module attribute for each stablehlo function.
// Returns the new stablehlo main function's name or error.
//
// If we directly insert stablehlo functions into tf module, MLIR will rename
// the stablehlo functions themselves in the tf module automatically to avoid

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package asan contains helper functions for manually instrumenting
// code for the address sanitizer.
// The runtime package intentionally exports these functions only in the
// asan build; this package exports them unconditionally but without the
// "asan" build tag they are no-ops.

  because they have untyped words on the stack.

- Functions that must not be preempted on entry.

- Functions that may run without a valid G. For example, functions
  that run in early runtime start-up, or that may be entered from C
  code such as cgo callbacks or the signal handler.

Splittable functions ensure there's some amount of space on the stack
for nosplit functions to run in and the linker checks that any static