Type:                              EXEC (Executable file)
 Machine:                           Intel 80386
 Version:                           0x1
 Entry point address:               0x8048310
 Start of program headers:          52 (bytes into file)
 Start of section headers:          4400 (bytes into file)
 Flags:                             0x0
 Size of this header:               52 (bytes)
 Size of program headers:           32 (bytes)

	case "wasip1":
		writeUleb128(ctxt.Out, 2) // number of exports
		s := ldr.Lookup("_rt0_wasm_wasip1", 0)
		idx := uint32(lenHostImports) + uint32(ldr.SymValue(s)>>16) - funcValueOffset
		writeName(ctxt.Out, "_start")       // the wasi entrypoint
		ctxt.Out.WriteByte(0x00)            // func export
		writeUleb128(ctxt.Out, uint64(idx)) // funcidx
		writeName(ctxt.Out, "memory")       // memory in wasi

	//   Machine:                           Intel 80386
	//   Version:                           0x1
	//   Entry point address:               0x0
	//   Start of program headers:          0 (bytes into file)
	//   Start of section headers:          3003468 (bytes into file)
	//   Flags:                             0x0
	//   Size of this header:               52 (bytes)

{
	struct GoStart_return r;

	// Use Go to start 4 goroutines each of which handles 1/4 of the
	// board.
	r = GoStart(0, x, y, 0, x / 2, 0, y / 2, a, n);
	assert(r.r0 == 0 && r.r1 == 100);	// test multiple returns
	r = GoStart(1, x, y, x / 2, x, 0, y / 2, a, n);
	assert(r.r0 == 1 && r.r1 == 101);	// test multiple returns
	GoStart(2, x, y, 0, x / 2, y / 2, y, a, n);
	GoStart(3, x, y, x / 2, x, y / 2, y, a, n);
	GoWait(0);
	GoWait(1);

// first running goroutine in the traceback.
//
// If either of these flags is set, Start re-executes the current
// executable as a child process, in a special mode in which it
// acts as a telemetry sidecar for the parent process (the application).
// In that mode, the call to Start will never return, so Start must
// be called immediately within main, even before such things as

	slices.SortStableFunc(opts.tasks, func(a, b *trace.UserTaskSummary) int {
		aStart, bStart := parsed.startTime(), parsed.startTime()
		if a.Start != nil {
			aStart = a.Start.Time()
		}
		if b.Start != nil {
			bStart = b.Start.Time()
		}
		if a.Start != b.Start {
			return cmp.Compare(aStart, bStart)
		}
		// Break ties with the end time.
		aEnd, bEnd := parsed.endTime(), parsed.endTime()

ECHO_ARGS=${ECHO_ARGS:-}
# Split ECHO_ARGS by spaces.
IFS=' ' read -r -a ECHO_ARGS_ARRAY <<< "$ECHO_ARGS"

ISTIO_LOG_DIR=${ISTIO_LOG_DIR:-/var/log/istio}

# Run the pilot agent and Envoy
/usr/local/bin/istio-start.sh&

# Start the echo server.

if [ "${EXEC_USER}" == "${USER:-}" ] ; then
  # if started as istio-proxy (or current user), do a normal start, without
  # redirecting stderr.
  INSTANCE_IP=${ISTIO_SVC_IP} POD_NAME=${POD_NAME} POD_NAMESPACE=${NS} "${ISTIO_BIN_BASE}/pilot-agent" proxy "${ISTIO_AGENT_FLAGS_ARRAY[@]}"
else

	// Trace a few times.
	for i := 0; i < 10; i++ {
		var buf bytes.Buffer
		if err := trace.Start(&buf); err != nil {
			log.Fatalf("failed to start tracing: %v", err)
		}
		runtime.GC()
		trace.Stop()
	}

	// Start tracing again, this time writing out the result.
	if err := trace.Start(os.Stdout); err != nil {
		log.Fatalf("failed to start tracing: %v", err)
	}
	runtime.GC()
	trace.Stop()

				}
			}
		}

		tStart := time.Now()
		p.fn(f)
		tEnd := time.Now()

		// Need something less crude than "Log the whole intermediate result".
		if f.Log() || f.HTMLWriter != nil {
			time := tEnd.Sub(tStart).Nanoseconds()
			var stats string
			if logMemStats {
				var mEnd runtime.MemStats
				runtime.ReadMemStats(&mEnd)
				nBytes := mEnd.TotalAlloc - mStart.TotalAlloc