}
    }

    private fun KaSession.renderAnnotationApplication(call: KaAnnotation, printer: PrettyPrinter) {
        with(printer) {
            renderValue(call.classId, printer, renderSymbolsFully = false)
            append('(')
            call.arguments.sortedBy { it.name }.forEachIndexed { index, value ->
                if (index > 0) {
                    append(", ")

        if (candidates.isEmpty()) {
            testServices.assertions.assertEquals(null, resolvedCall) {
                "Inconsistency between candidates and resolved call. " +
                        "Resolved call is not null, but no candidates found.\n" +
                        stringRepresentation(resolvedCall)
            }
        } else {
            if (resolvedCall == null) return

        is ErrorReason.UnresolvedFunctionCallArguments -> "unresolved function call arguments for '${errorReason.functionCall.name}'"
        is ErrorReason.UnresolvedFunctionCallReceiver -> "unresolved function call receiver for '${errorReason.functionCall.name}'"
        is ErrorReason.UnresolvedFunctionCallSignature -> "unresolved function call signature for '${errorReason.functionCall.name}'"

	go func() {
		// This call is typically inlined.
		child1()
	}()
	select {}
}

func child1() {
	child2()
}

func child2() {
	child3()
}

func child3() {
	child4()
}

func child4() {
	child5()
}

//go:noinline
func child5() { // test trace through second of two call instructions
	child6bad()
	child6() // appears in stack trace
}

		// the stack frame but we're not going back there
		// anyway.
		if usesLR {
			c.savelr(c.lr())
		}

		// If PC == 0, probably panicked because of a call to a nil func.
		// Not faking that as the return address will make the trace look like a call
		// to sigpanic instead. (Otherwise the trace will end at
		// sigpanic and we won't get to see who faulted).
		if pc != 0 {
			if usesLR {
				c.setlr(pc)
			} else {

    String getName();

    /**
     * This method or {@link #withInputStream(IoFunction)} ()} may or may not support being called more than
     * once per entry.  Use {@link #canReopen()} to determine if more than one call is supported.
     */
    byte[] getContent() throws IOException;

    /**
     * Declare an action to be run against this ZipEntry's content as a {@link InputStream}.

     * fun foo(): (bar: String) -> Unit { ... }
     *
     * // source code
     * fun test() {
     *   val action = foo()
     *   action("") // this call
     * }
     * ```
     *
     * Unfortunately, [symbol] for the `action("")` call will be pointing to the `Function1<P1, R>.invoke(p1: P1): R`, because we

// license that can be found in the LICENSE file.

package coverage

import (
	"internal/coverage/cfile"
	"io"
)

// initHook is invoked from main.init in programs built with -cover.
// The call is emitted by the compiler.
func initHook(istest bool) {
	cfile.InitHook(istest)
}

// WriteMetaDir writes a coverage meta-data file for the currently
// running program to the directory specified in 'dir'. An error will

// call KeepAlive(p) after the call to syscall.Write.
//
// A single goroutine runs all finalizers for a program, sequentially.
// If a finalizer must run for a long time, it should do so by starting
// a new goroutine.
//
// In the terminology of the Go memory model, a call
// SetFinalizer(x, f) “synchronizes before” the finalization call f(x).

KaDataFlowExitPointSnapshot:
  defaultExpressionInfo = DefaultExpressionInfo:
    expression = foo.call()
    type = kotlin.String!
  hasEscapingJumps = false
  hasJumps = false
  hasMultipleJumpKinds = false
  hasMultipleJumpTargets = false
  jumpExpressions = []
  returnValueType = null
  valuedReturnExpressions = []