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

package counter

import (
	"bytes"
	"fmt"
	"strings"
	"unsafe"

	"golang.org/x/telemetry/internal/mmap"
)

type File struct {
	Meta  map[string]string
	Count map[string]uint64
}

func Parse(filename string, data []byte) (*File, error) {
	if !bytes.HasPrefix(data, []byte(hdrPrefix)) || len(data) < pageSize {
		if len(data) < pageSize {

		{"struct{}", args{reflect.TypeOf(struct{}{})}, true},
		{"struct{i int; s S}", args{reflect.TypeOf(struct {
			i int
			s S
		}{})}, true},
		{"map[int][int]", args{reflect.TypeOf(map[int]int{})}, false},
		{"[4]chan int", args{reflect.TypeOf([4]chan int{})}, true},
		{"[0]struct{_ S}", args{reflect.TypeOf([0]struct {
			_ S
		}{})}, true},

	"uncommonType",
	"arrayType",
	"chanType",
	"funcType",
	"interfaceType",
	"ptrType",
	"sliceType",
	"structType",
}

type visitor struct {
	m map[string]map[string]bool
}

func newVisitor() visitor {
	v := visitor{}
	v.m = make(map[string]map[string]bool)

	return v
}
func (v visitor) filter(name string) bool {
	for _, typeName := range typeNames {
		if typeName == name {
			return true
		}

		CounterMode:        cmode,
		CounterGranularity: cgran,
	})
	if pkgid != -1 {
		if Meta.PkgMap == nil {
			Meta.PkgMap = make(map[int]int)
		}
		if _, ok := Meta.PkgMap[pkgid]; ok {
			return 0
		}
		// Record the real slot (position on meta-list) for this
		// package; we'll use the map to fix things up later on.
		Meta.PkgMap[pkgid] = slot
	}

	// ID zero is reserved as invalid.
	return uint32(slot + 1)

	mutex   sync.Mutex        // protects pending
	pending map[uint64]string // map request id to method name
}

// NewClientCodec returns a new [rpc.ClientCodec] using JSON-RPC on conn.
func NewClientCodec(conn io.ReadWriteCloser) rpc.ClientCodec {
	return &clientCodec{
		dec:     json.NewDecoder(conn),
		enc:     json.NewEncoder(conn),
		c:       conn,
		pending: make(map[uint64]string),
	}
}

type clientRequest struct {

package main

// issue 8142: lost 'addrtaken' bit on inlined variables.

func printnl()

//go:noescape
func useT40(*T40)

type T40 struct {
	m map[int]int
}

func newT40() *T40 {
	ret := T40{}
	ret.m = make(map[int]int, 42) // ERROR "live at call to makemap: &ret$"
	return &ret
}

func bad40() {
	t := newT40() // ERROR "stack object ret T40$" "stack object .autotmp_[0-9]+ runtime.hmap$"

	// We must use a lookup on identity rather than a simple map[*Named]bool as
	// instantiated types may be identical but not equal.
	var seen instanceLookup

	// collect methods at current depth
	for len(current) > 0 {
		var next []embeddedType // embedded types found at current depth

		// field and method sets at current depth, indexed by names (Id's), and allocated lazily
		var fset map[string]bool // we only care about the field names

			go121Events: convertOldFormat(tr),
		}, nil
	case version.Go122, version.Go123:
		return &Reader{
			r: br,
			order: ordering{
				mStates:     make(map[ThreadID]*mState),
				pStates:     make(map[ProcID]*pState),
				gStates:     make(map[GoID]*gState),
				activeTasks: make(map[TaskID]taskState),
			},
			// Don't emit a sync event when we first go to emit events.
			emittedSync: true,
		}, nil
	default:

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test that a linkname applied on an assembly declaration
// does not affect stack map generation.

package main

import (
	"runtime"
	_ "unsafe"
)

//go:linkname asm
func asm(*int)

func main() {
	x := new(int)
	asm(x)
}

// called from asm
func callback() {

		os.Exit(exitCode)
	}

	sort.Sort(byDate(fixes))

	if *allowedRewrites != "" {
		allowed = make(map[string]bool)
		for _, f := range strings.Split(*allowedRewrites, ",") {
			allowed[f] = true
		}
	}

	if *forceRewrites != "" {
		force = make(map[string]bool)
		for _, f := range strings.Split(*forceRewrites, ",") {
			force[f] = true
		}
	}

	if flag.NArg() == 0 {