munmapFile(*previous)
	}
	st, err := f.Stat()
	if err != nil {
		return Data{}, err
	}
	size := st.Size()
	if size == 0 {
		return Data{f, nil, nil}, nil
	}
	// set the min and max sizes to zero to map the whole file, as described in
	// https://learn.microsoft.com/en-us/windows/win32/memory/creating-a-file-mapping-object#file-mapping-size

		{Basic{}, 16, 32},
		{Array{}, 16, 24},
		{Slice{}, 8, 16},
		{Struct{}, 24, 48},
		{Pointer{}, 8, 16},
		{Tuple{}, 12, 24},
		{Signature{}, 28, 56},
		{Union{}, 12, 24},
		{Interface{}, 40, 80},
		{Map{}, 16, 32},
		{Chan{}, 12, 24},
		{Named{}, 60, 112},
		{TypeParam{}, 28, 48},
		{term{}, 12, 24},

		// Objects
		{PkgName{}, 48, 88},
		{Const{}, 48, 88},
		{TypeName{}, 40, 72},
		{Var{}, 48, 88},

	if err != nil {
		// pprof expects a map entry, so fake one, when we haven't added anything yet.
		b.addMappingEntry(0, 0, 0, "", "", true)
		return
	}
	defer func() { _ = syscall.CloseHandle(snap) }()

	var module windows.ModuleEntry32
	module.Size = uint32(windows.SizeofModuleEntry32)
	err = windows.Module32First(snap, &module)
	if err != nil {
		// pprof expects a map entry, so fake one, when we haven't added anything yet.

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

package pgo

import (
	"bufio"
	"fmt"
	"io"
)

// Serialization of a Profile allows go tool preprofile to construct the edge
// map only once (rather than once per compile process). The compiler processes
// then parse the pre-processed data directly from the serialized format.
//
// The format of the serialized output is as follows.
//

// throw. go_bootstrap cannot depend on the cgo version of package net in ./make.bash.
package format

type Data struct {
	Events   []*Event         `json:"traceEvents"`
	Frames   map[string]Frame `json:"stackFrames"`
	TimeUnit string           `json:"displayTimeUnit"`
}

type Event struct {
	Name      string  `json:"name,omitempty"`
	Phase     string  `json:"ph"`

	cmd = exec.Command(testenv.GoToolPath(t), "tool", "dist", "list")
	cmd.Stderr = os.Stderr
	out, err = cmd.Output()
	if err != nil {
		log.Fatalf("loading architecture list: %v\n%s", err, out)
	}
	allGOARCH := make(map[string]bool)
	for _, pair := range strings.Split(strings.TrimSpace(string(out)), "\n") {
		GOARCH := strings.Split(pair, "/")[1]
		allGOARCH[GOARCH] = true
	}

	for _, pkgName := range pkgs {

	f()
	go f()
}

// Same, but function has a parameter and return value.
func _[T interface{ ~func(string) int }](f T) int {
	return f("hello")
}

// Map access of a generic type which has a map as core type.
func _[V any, T interface{ ~map[string]V }](p T) V {
	return p["test"]
}

// Testing partial and full type inference, including the case where the types can

	}

	// Pick up any changes to the baseline configuration from the
	// GOEXPERIMENT environment. This can be set at make.bash time
	// and overridden at build time.
	if goexp != "" {
		// Create a map of known experiment names.
		names := make(map[string]func(bool))
		rv := reflect.ValueOf(&flags.Flags).Elem()
		rt := rv.Type()
		for i := 0; i < rt.NumField(); i++ {
			field := rv.Field(i)

	"time"
)

// TestDescriptions checks that the profile names under runtime/pprof package
// have a key in the description map.
func TestDescriptions(t *testing.T) {
	for _, p := range pprof.Profiles() {
		_, ok := profileDescriptions[p.Name()]
		if ok != true {
			t.Errorf("%s does not exist in profileDescriptions map\n", p.Name())
		}
	}
}

func TestHandlers(t *testing.T) {
	testCases := []struct {
		path               string

			if e != nil {
				t.Errorf("ParseBool(%s) = %s; want nil", test.in, e)
			}
			if b != test.out {
				t.Errorf("ParseBool(%s) = %t; want %t", test.in, b, test.out)
			}
		}
	}
}

var boolString = map[bool]string{
	true:  "true",
	false: "false",
}

func TestFormatBool(t *testing.T) {
	for b, s := range boolString {
		if f := FormatBool(b); f != s {
			t.Errorf("FormatBool(%v) = %q; want %q", b, f, s)
		}