{
        "name": "nameValue",
        "attributes": [
          {
            "name": "nameValue",
            "quantity": "0",
            "bool": true,
            "int": 7,
            "intSlice": {
              "ints": [
                1
              ]
            },
            "string": "stringValue",
            "stringSlice": {
              "strings": [
                "stringsValue"

	}
	Strings(x)
	return x
}

const N = 100_000

func BenchmarkSortInts(b *testing.B) {
	for i := 0; i < b.N; i++ {
		b.StopTimer()
		ints := makeRandomInts(N)
		b.StartTimer()
		Sort(IntSlice(ints))
	}
}

func BenchmarkSlicesSortInts(b *testing.B) {
	for i := 0; i < b.N; i++ {
		b.StopTimer()
		ints := makeRandomInts(N)
		b.StartTimer()
		slices.Sort(ints)
	}
}

    name: nameValue
    uid: uidValue
  resourceVersion: resourceVersionValue
  selfLink: selfLinkValue
  uid: uidValue
namedResources:
  instances:
  - attributes:
    - bool: true
      int: 7
      intSlice:
        ints:
        - 1
      name: nameValue
      quantity: "0"
      string: stringValue
      stringSlice:
        strings:
        - stringsValue
      version: versionValue
    name: nameValue

      (OffPtr <typ.BytePtrPtr> [config.PtrSize] ptr)
      mem)

(SlicePtr x:(Load <t> ptr mem)) && t.IsSlice() => @x.Block (Load <t.Elem().PtrTo()> ptr mem)
(SliceLen x:(Load <t> ptr mem)) && t.IsSlice() => @x.Block (Load <typ.Int>
      (OffPtr <typ.IntPtr> [config.PtrSize] ptr)
      mem)
(SliceCap x:(Load <t> ptr mem)) && t.IsSlice() => @x.Block (Load <typ.Int>
      (OffPtr <typ.IntPtr> [2*config.PtrSize] ptr)
      mem)

func (z *nsScannerResp) Msgsize() (s int) {
	s = 1 + 2
	if z.Update == nil {
		s += msgp.NilSize
	} else {
		s += z.Update.Msgsize()
	}
	s += 2
	if z.Final == nil {
		s += msgp.NilSize
	} else {
		s += z.Final.Msgsize()
	}
	return

	n := data.Len()
	for i := n - 1; i > 0; i-- {
		if data.Less(i, i-1) {
			return false
		}
	}
	return true
}
func TestGenericSorted(t *testing.T) {
	var data = sort.IntSlice{-10, -5, 0, 1, 2, 3, 5, 7, 11, 100, 100, 100, 1000, 10000}
	f := func() {
		genericSorted(data)
	}
	if n := testing.AllocsPerRun(10, f); n > 0 {
		t.Errorf("got %f allocs, want 0", n)
	}
}

	// IntValue is a 64-bit integer.
	IntValue *int64 `json:"int,omitempty" protobuf:"varint,7,opt,name=int"`
	// IntSliceValue is an array of 64-bit integers.
	IntSliceValue *NamedResourcesIntSlice `json:"intSlice,omitempty" protobuf:"varint,8,rep,name=intSlice"`
	// StringValue is a string.
	StringValue *string `json:"string,omitempty" protobuf:"bytes,5,opt,name=string"`
	// StringSliceValue is an array of strings.

	name   string
	result int
	i      int
}{
	{"SearchInts", SearchInts(data, 11), 8},
	{"SearchFloat64s", SearchFloat64s(fdata, 2.1), 4},
	{"SearchStrings", SearchStrings(sdata, ""), 0},
	{"IntSlice.Search", IntSlice(data).Search(0), 2},
	{"Float64Slice.Search", Float64Slice(fdata).Search(2.0), 3},
	{"StringSlice.Search", StringSlice(sdata).Search("x"), 3},
}

func TestSearchWrappers(t *testing.T) {

// so type inference should be able to handle these cases well.

func g1[T any]([]T) {}
func g2[T any]([]T, T) {}
func g3[T any](*T, ...T) {}

func _() {
	type intSlice []int
	g1([]int{})
	g1(intSlice{})
	g2(nil, 0)

	type myString string
	var s1 string
	g3(nil, "1", myString("2"), "3")

package lex

import (
	"text/scanner"

	"cmd/internal/src"
)

// A Slice reads from a slice of Tokens.
type Slice struct {
	tokens []Token
	base   *src.PosBase
	line   int
	pos    int
}

func NewSlice(base *src.PosBase, line int, tokens []Token) *Slice {
	return &Slice{
		tokens: tokens,
		base:   base,
		line:   line,
		pos:    -1, // Next will advance to zero.
	}
}

func (s *Slice) Next() ScanToken {