//	if err != nil {
//		return nil, err
//	}
//	return c.ReadCodeLine(250)
func (c *Conn) Cmd(format string, args ...any) (id uint, err error) {
	id = c.Next()
	c.StartRequest(id)
	err = c.PrintfLine(format, args...)
	c.EndRequest(id)
	if err != nil {
		return 0, err
	}
	return id, nil
}

// TrimString returns s without leading and trailing ASCII space.
func TrimString(s string) string {

		}
		if attribute.BoolValue != nil {
			entries.Insert("bool")
		}
		if attribute.IntValue != nil {
			entries.Insert("int")
		}
		if attribute.IntSliceValue != nil {
			entries.Insert("intSlice")
		}
		if attribute.StringValue != nil {
			entries.Insert("string")
		}
		if attribute.StringSliceValue != nil {
			entries.Insert("stringSlice")
		}
		if attribute.VersionValue != nil {

		maxCount := permutations * int(math.Ceil(nff))
		aHand := make([]int, test.handSize)
		for i := 0; i < test.hashMax; i++ {
			aHand = dealer.DealIntoHand(uint64(i), aHand)
			sort.IntSlice(aHand).Sort()
			handCoordinate := 0
			for _, card := range aHand {
				handCoordinate = handCoordinate<<7 + card
			}
			handCoordinateMap[handCoordinate]++
		}
		numHandsSeen := len(handCoordinateMap)

func SearchStrings(a []string, x string) int {
	return Search(len(a), func(i int) bool { return a[i] >= x })
}

// Search returns the result of applying [SearchInts] to the receiver and x.
func (p IntSlice) Search(x int) int { return SearchInts(p, x) }

// Search returns the result of applying [SearchFloat64s] to the receiver and x.
func (p Float64Slice) Search(x float64) int { return SearchFloat64s(p, x) }

			clear:    "%s.clear()",
			minLog:   5,
			maxLog:   32,
		},
	}
	deriveds := []derived{
		{
			name: "BlockSlice",
			typ:  "[]*Block",
			base: "ValueSlice",
		},
		{
			name: "IntSlice",
			typ:  "[]int",
			base: "Int64Slice",
		},
		{
			name: "Int32Slice",
			typ:  "[]int32",
			base: "Int64Slice",
		},
		{
			name: "Int8Slice",
			typ:  "[]int8",

	})
}

var (
	SinkIntSlice        []int
	SinkIntPointerSlice []*int
)

func BenchmarkExtendSlice(b *testing.B) {
	var length = 4 // Use a variable to prevent stack allocation of slices.
	b.Run("IntSlice", func(b *testing.B) {
		s := make([]int, 0, length)
		for i := 0; i < b.N; i++ {
			s = append(s[:0:length/2], make([]int, length)...)
		}
		SinkIntSlice = s
	})
	b.Run("PointerSlice", func(b *testing.B) {

  optional bool bool = 2;

  // IntValue is a 64-bit integer.
  optional int64 int = 7;

  // IntSliceValue is an array of 64-bit integers.
  optional NamedResourcesIntSlice intSlice = 8;

  // StringValue is a string.
  optional string string = 5;

  // StringSliceValue is an array of strings.
  optional NamedResourcesStringSlice stringSlice = 9;

		{"(Float64Slice).Search", Method, 0},
		{"(Float64Slice).Sort", Method, 0},
		{"(Float64Slice).Swap", Method, 0},
		{"(IntSlice).Len", Method, 0},
		{"(IntSlice).Less", Method, 0},
		{"(IntSlice).Search", Method, 0},
		{"(IntSlice).Sort", Method, 0},
		{"(IntSlice).Swap", Method, 0},
		{"(StringSlice).Len", Method, 0},
		{"(StringSlice).Less", Method, 0},
		{"(StringSlice).Search", Method, 0},

function isForcedGarbageCollectionEvent(event){return findParent(event,isLowMemoryEvent)!==null;}
function isSubGarbageCollectionEvent(event){return isGarbageCollectionEvent(event)&&event.parentSlice&&(isTopGarbageCollectionEvent(event.parentSlice)||event.parentSlice.title===MAJOR_GC_EVENT||event.parentSlice.title===MINOR_GC_EVENT);}

pkg sort, method (Float64Slice) Sort()
pkg sort, method (Float64Slice) Swap(int, int)
pkg sort, method (IntSlice) Len() int
pkg sort, method (IntSlice) Less(int, int) bool
pkg sort, method (IntSlice) Search(int) int
pkg sort, method (IntSlice) Sort()
pkg sort, method (IntSlice) Swap(int, int)
pkg sort, method (StringSlice) Len() int
pkg sort, method (StringSlice) Less(int, int) bool