hiliter: (n, on) => { return hilite(n, on); },
    current: () => {
      let r = new Map();
      if (pivots.length == 1 && pivots[0] == 0) {
        // Not pivoting
      } else {
        for (let p of pivots) {
          r.set(p, true);
        }
      }
      return r;
    }});

  render();

  // Helper functions follow:

	} {
		t.Run(test, func(t *testing.T) {
			checkCoroTestProgOutput(t, runTestProg(t, "testprogcgo", test))
		})
	}
}

func checkCoroTestProgOutput(t *testing.T, output string) {
	t.Helper()

	c := strings.SplitN(output, "\n", 2)
	if len(c) == 1 {
		t.Fatalf("expected at least one complete line in the output, got:\n%s", output)
	}
	expect, ok := strings.CutPrefix(c[0], "expect: ")
	if !ok {

}

func readArg(s string) (arg string, value uint64, rest string, err error) {
	var tok string
	tok, rest = readToken(s)
	if len(tok) == 0 {
		return "", 0, s, fmt.Errorf("no argument")
	}
	parts := strings.SplitN(tok, "=", 2)
	if len(parts) < 2 {
		return "", 0, s, fmt.Errorf("malformed argument: %q", tok)
	}
	arg = parts[0]
	value, err = strconv.ParseUint(parts[1], 10, 64)
	if err != nil {

	substr := []byte(leadColon + value + ":")
	return func(line []byte) (v any, err error) {
		if !bytes.Contains(line, substr) || bytes.Count(line, colon) < 3 {
			return
		}
		// wheel:*:0:root
		parts := strings.SplitN(string(line), ":", 4)
		if len(parts) < 4 || parts[0] == "" || parts[idx] != value ||
			// If the file contains +foo and you search for "foo", glibc
			// returns an "invalid argument" error. Similarly, if you search

	} else {
		Args = commandLineToArgv(cmd)
	}
}

// appendBSBytes appends n '\\' bytes to b and returns the resulting slice.
func appendBSBytes(b []byte, n int) []byte {
	for ; n > 0; n-- {
		b = append(b, '\\')
	}
	return b
}

// readNextArg splits command line string cmd into next
// argument and command line remainder.
func readNextArg(cmd string) (arg []byte, rest string) {
	var b []byte

	cmd := exec.Command("go", "tool", "link", "-B", buildid)
	out, err := cmd.CombinedOutput()
	if err == nil {
		log.Fatalf("expected cmd/link to fail")
	}

	firstLine := string(bytes.SplitN(out, []byte("\n"), 2)[0])
	if strings.HasPrefix(firstLine, "panic") {
		log.Fatalf("cmd/link panicked:\n%s", out)
	}

	if !strings.Contains(firstLine, message) {

// splice wraps the splice system call. Since the current implementation
// only uses splice on sockets and pipes, the offset arguments are unused.
// splice returns int instead of int64, because callers never ask it to
// move more data in a single call than can fit in an int32.
func splice(out int, in int, max int, flags int) (int, error) {
	n, err := syscall.Splice(in, nil, out, nil, max, flags)
	return int(n), err
}

		}
	} else {
		r = src
	}
	// Now call ReadFrom (through io.Copy), which will hopefully call poll.Splice
	n, err := io.Copy(dst, r)
	if err != nil {
		t.Fatal(err)
	}

	// We should have called poll.Splice with the right file descriptor arguments.
	if n > 0 && !hook.called {
		t.Fatal("expected to called poll.Splice")
	}
	if hook.called && hook.dstfd != int(dst.Fd()) {

	b = b[:end+(n*2)]
	// Copy the block of bytes we want to duplicate to the end of the
	// slice
	copy(b[end+n:], b[src:src+n])
	// Shift the bytes after the splice point n positions to the right
	// to make room for the new block
	copy(b[dst+n:end+n], b[dst:end])
	// Insert the duplicate block into the splice point
	copy(b[dst:], b[end+n:])
	b = b[:end+n]
	return b
}

func trim(f *Func) {
	n := 0
	for _, b := range f.Blocks {
		if !trimmableBlock(b) {
			f.Blocks[n] = b
			n++
			continue
		}

		bPos := b.Pos
		bIsStmt := bPos.IsStmt() == src.PosIsStmt

		// Splice b out of the graph. NOTE: `mergePhi` depends on the
		// order, in which the predecessors edges are merged here.
		p, i := b.Preds[0].b, b.Preds[0].i
		s, j := b.Succs[0].b, b.Succs[0].i
		ns := len(s.Preds)