p.dump(x.Index(i), nil)
				p.printf("\n")
			}
			p.indent--
		}
		p.printf("}")

	case reflect.Struct:
		typ := x.Type()

		// if span, ok := x.Interface().(lexical.Span); ok {
		// 	p.printf("%s", &span)
		// 	return
		// }

		p.printf("%s {", typ)
		p.indent++

		first := true
		if n != nil {
			p.printf("\n")
			first = false
			// p.printf("Span: %s\n", n.Span())

  if (!ran_init) {
    fprintf(stderr, "ERROR: DidInitRun returned unexpected results: %d\n",
            ran_init);
    return 1;
  }
  int8_t ran_main = DidMainRun();
  if (ran_main) {
    fprintf(stderr, "ERROR: DidMainRun returned unexpected results: %d\n",
            ran_main);
    return 1;
  }
  int32_t from_pkg = FromPkg();
  if (from_pkg != 1024) {

func (err *error_) msg() string {
	if err.empty() {
		return "no error"
	}

	var buf strings.Builder
	for i := range err.desc {
		p := &err.desc[i]
		if i > 0 {
			fmt.Fprint(&buf, "\n\t")
			if p.posn.Pos().IsValid() {
				fmt.Fprintf(&buf, "%s: ", err.check.fset.Position(p.posn.Pos()))
			}
		}
		buf.WriteString(p.msg)
	}
	return buf.String()
}

		log.Fatal("usage: encgen [--output filename]")
	}
	var b bytes.Buffer
	fmt.Fprintf(&b, "// Code generated by go run encgen.go -output %s; DO NOT EDIT.\n", *output)
	fmt.Fprint(&b, header)
	printMaps(&b, "Array")
	fmt.Fprint(&b, "\n")
	printMaps(&b, "Slice")
	for _, t := range types {
		fmt.Fprintf(&b, arrayHelper, t.lower, t.upper)
		fmt.Fprintf(&b, sliceHelper, t.lower, t.upper, t.zero, t.encoder)
	}

	defer coverMerge.Unlock()

	expect := fmt.Sprintf("mode: %s\n", cfg.BuildCoverMode)
	buf := make([]byte, len(expect))
	r, err := os.Open(file)
	if err != nil {
		// Test did not create profile, which is OK.
		return
	}
	defer r.Close()

	n, err := io.ReadFull(r, buf)
	if n == 0 {
		return
	}
	if err != nil || string(buf) != expect {
		fmt.Fprintf(ew, "error: test wrote malformed coverage profile %s.\n", file)

int check_int8(void* handle, const char* fname, int8_t want) {
  int8_t (*fn)();
  fn = (int8_t (*)())dlsym(handle, fname);
  if (!fn) {
    fprintf(stderr, "ERROR: missing %s: %s\n", fname, dlerror());
    return 1;
  }
  signed char ret = fn();
  if (ret != want) {
    fprintf(stderr, "ERROR: %s=%d, want %d\n", fname, ret, want);
    return 1;
  }
  return 0;
}

	buf := new(bytes.Buffer)
	fmt.Fprintf(buf, "TEXT a(SB),$0-0\n")
	for i := 0; i < 1<<17; i++ {
		fmt.Fprintf(buf, "\tADD $0, X0, X0\n")
	}
	fmt.Fprintf(buf, "\tCALL b(SB)\n")
	fmt.Fprintf(buf, "\tRET\n")
	fmt.Fprintf(buf, "TEXT b(SB),$0-0\n")
	fmt.Fprintf(buf, "\tRET\n")
	fmt.Fprintf(buf, "TEXT c(SB),$0-0\n")
	fmt.Fprintf(buf, "\tCALL b(SB)\n")
	fmt.Fprintf(buf, "\tRET\n")

		if err != nil {
			if err != io.EOF {
				fmt.Println("failed to read data, err:", err)
			}
			return
		}
		fmt.Printf("request: %s", bytes)

		// prepend prefix and send as response
		line := fmt.Sprintf("%s %s", prefix, bytes)
		fmt.Printf("response: %s", line)
		conn.Write([]byte(line))
	}

type big struct {
	pile [768]int8
}

type thing struct {
	name  string
	next  *thing
	self  *thing
	stuff []big
}

func test(t *thing, u *thing) {
	if t.next != nil {
		return
	}
	fmt.Fprintf(os.Stderr, "%s\n", t.name)
	u.self = u
	t.self = t
	t.next = u
	for _, p := range t.stuff {
		if isFoo(t, p) {
			return
		}
	}
}

//go:noinline
func isFoo(t *thing, b big) bool {
	return true

	// Now emit blobs themselves.
	for k, blob := range blobs {
		if m.debug {
			fmt.Fprintf(os.Stderr, "=+= writing blob %d len %d at off=%d hash %s\n", k, len(blob), off2, fmt.Sprintf("%x", md5.Sum(blob)))
		}
		if _, err = m.w.Write(blob); err != nil {
			return fmt.Errorf("error writing %s: %v", m.mfname, err)
		}
		if m.debug {
			fmt.Fprintf(os.Stderr, "=+= wrote package payload of %d bytes\n",
				len(blob))
		}