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) {

		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)
	}

	for range depth {
		fmt.Fprintf(&sb, "\t")
	}
	prefix := sb.String()
	if n.isEntry {
		e := n.entry()
		for e != nil {
			fmt.Printf("%s%p [Entry Key=%v Value=%v Overflow=%p, Hash=%016x]\n", prefix, e, e.key, e.value, e.overflow.Load(), ht.keyHash(unsafe.Pointer(&e.key), ht.seed))
			e = e.overflow.Load()
		}
		return
	}
	i := n.indirect()

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;
}

	if w.lastpart != nil {
		fmt.Fprintf(&b, "\r\n--%s\r\n", w.boundary)
	} else {
		fmt.Fprintf(&b, "--%s\r\n", w.boundary)
	}

	keys := make([]string, 0, len(header))
	for k := range header {
		keys = append(keys, k)
	}
	slices.Sort(keys)
	for _, k := range keys {
		for _, v := range header[k] {
			fmt.Fprintf(&b, "%s: %s\r\n", k, v)
		}
	}
	fmt.Fprintf(&b, "\r\n")
	_, err := io.Copy(w.w, &b)

		switch in := in.(type) {
		case *md.Plain:
			dprintf(depth, "Plain(%q)\n", in.Text)
		case *md.Code:
			dprintf(depth, "Code(%q)\n", in.Text)
		case *md.Link:
			dprintf(depth, "Link:\n")
			dumpInlines(in.Inner, depth+1)
			dprintf(depth+1, "URL: %q\n", in.URL)
		case *md.Strong:
			dprintf(depth, "Strong(%q):\n", in.Marker)
			dumpInlines(in.Inner, depth+1)
		case *md.Emph:
			dprintf(depth, "Emph(%q):\n", in.Marker)

		{Key: "name", Value: v.name},
		{Key: "uid", Value: string(v.uid)},
		{Key: "missing", Value: fmt.Sprintf(`%v`, v.missingFromGraph)},
		{Key: "beingDeleted", Value: fmt.Sprintf(`%v`, v.beingDeleted)},
		{Key: "deletingDependents", Value: fmt.Sprintf(`%v`, v.deletingDependents)},
		{Key: "virtual", Value: fmt.Sprintf(`%v`, v.virtual)},
	}
}

// NewDOTVertex creates a new dotVertex.

		fmt.Fprintf(w, "    t.Errorf(\"t%dcopy got=%%v, want %%v\\n\", a, want)\n", s)
		fmt.Fprintf(w, "  }\n")
		fmt.Fprintf(w, "}\n")
	}

	for _, s := range usizes {
		// function being tested
		fmt.Fprintf(w, "//go:noinline\n")
		fmt.Fprintf(w, "func tu%dcopy_ssa(docopy bool, data [%d]byte, x *[%d]byte) {\n", s, s, s)
		fmt.Fprintf(w, "  if docopy {\n")
		fmt.Fprintf(w, "    *x = data\n")
		fmt.Fprintf(w, "  }\n")
		fmt.Fprintf(w, "}\n")

func (ms *MetadataServer) getToken(w http.ResponseWriter, req *http.Request) {
	ms.mutex.Lock()
	defer ms.mutex.Unlock()

	ms.numGetTokenCall++
	token := fmt.Sprintf("%s%d", fakeTokenPrefix, ms.numGetTokenCall)
	if ms.credential != "" {
		token = ms.credential
	}
	fmt.Fprint(w, token)
}

func (ms *MetadataServer) Stop() {
	ms.server.Close()

  if (!handle) {
    fprintf(stderr, "ERROR: failed to open the shared library: %s\n",
            dlerror());
    return 2;
  }

  uintptr_t main_fn = (uintptr_t)dlsym(handle, "main.main");
  if (!main_fn) {
    fprintf(stderr, "ERROR: missing main.main: %s\n", dlerror());
    return 2;
  }

  // TODO(hyangah): check that main.main can run.

  printf("PASS\n");
  return 0;