// that are valid map keys.
package fmtsort

import (
	"cmp"
	"reflect"
	"slices"
)

// Note: Throughout this package we avoid calling reflect.Value.Interface as
// it is not always legal to do so and it's easier to avoid the issue than to face it.

// SortedMap is a slice of KeyValue pairs that simplifies sorting
// and iterating over map entries.
//

type evTable struct {
	freq    frequency
	strings dataTable[stringID, string]
	stacks  dataTable[stackID, stack]
	pcs     map[uint64]frame

	// extraStrings are strings that get generated during
	// parsing but haven't come directly from the trace, so
	// they don't appear in strings.
	extraStrings   []string
	extraStringIDs map[string]extraStringID
	nextExtra      extraStringID

	// expData contains extra unparsed data that is accessible

// A Switch represents a callpath point switch for socket system
// calls.
type Switch struct {
	once sync.Once

	fmu   sync.RWMutex
	fltab map[FilterType]Filter

	smu   sync.RWMutex
	sotab Sockets
	stats stats
}

func (sw *Switch) init() {
	sw.fltab = make(map[FilterType]Filter)
	sw.sotab = make(Sockets)
	sw.stats = make(stats)
}

// Stats returns a list of per-cookie socket statistics.

	m[k]--
}

func mapCompoundAssignmentString() {
	m := make(map[string]string, 0)
	var k string = "key"

	// 386:-".*mapaccess"
	// amd64:-".*mapaccess"
	// arm:-".*mapaccess"
	// arm64:-".*mapaccess"
	m[k] += "value"
}

var sinkAppend bool

func mapAppendAssignmentInt8() {
	m := make(map[int8][]int8, 0)
	var k int8 = 0

	// 386:-".*mapaccess"
	// amd64:-".*mapaccess"

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

// Another test to verify compiler and linker handling of multiple
// competing map.zero symbol definitions.

// a global) for tags, can include or exclude packages in the standard library,
// and is restricted to the given list of modules.
func matchPackages(ctx context.Context, m *search.Match, tags map[string]bool, filter stdFilter, modules []module.Version) {
	ctx, span := trace.StartSpan(ctx, "modload.matchPackages")
	defer span.Done()

	m.Pkgs = []string{}

	isMatch := func(string) bool { return true }

	parentLabels := labelValue(ctx)
	childLabels := make(labelMap, len(parentLabels))
	// TODO(matloob): replace the map implementation with something
	// more efficient so creating a child context WithLabels doesn't need
	// to clone the map.
	for k, v := range parentLabels {
		childLabels[k] = v
	}
	for _, label := range labels.list {
		childLabels[label.key] = label.value
	}

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