0x1, /* CallSiteInLoop */
	0x2, /* CallSiteOnPanicPath */
	0x4, /* CallSiteInInitFunc */
}

const _CSPropBits_name = "CallSiteInLoopCallSiteOnPanicPathCallSiteInInitFunc"

var _CSPropBits_index = [...]uint8{0, 14, 33, 51}

func (i CSPropBits) String() string {
	var b bytes.Buffer

	remain := uint64(i)
	seen := false

	for k, v := range _CSPropBits_value {

}
func benchmarkSwitchType(b *testing.B, predictable bool) {
	a := []any{
		int8(1),
		int16(2),
		int32(3),
		int64(4),
		uint8(5),
		uint16(6),
		uint32(7),
		uint64(8),
	}
	n := 0
	rng := newRNG()
	for i := 0; i < b.N; i++ {
		rng = rng.next(predictable)
		switch a[rng.value()&7].(type) {
		case int8:
			n += 1
		case int16:
			n += 2
		case int32:
			n += 3

	_ = x[ACPLX64-15]
	_ = x[ACPLX128-16]
	_ = x[ASPECIAL-17]
}

const _AlgKind_name = "UNKNOEQNOALGMEMMEM0MEM8MEM16MEM32MEM64MEM128STRINGINTERNILINTERFLOAT32FLOAT64CPLX64CPLX128SPECIAL"

var _AlgKind_index = [...]uint8{0, 3, 7, 12, 15, 19, 23, 28, 33, 38, 44, 50, 55, 63, 70, 77, 83, 90, 97}

func (i AlgKind) String() string {
	if i < 0 || i >= AlgKind(len(_AlgKind_index)-1) {
		return "AlgKind(" + strconv.FormatInt(int64(i), 10) + ")"
	}

var _scannerMetric_index = [...]uint8{0, 12, 24, 33, 41, 53, 65, 74, 77, 93, 98, 112, 127, 147, 157, 167, 186, 198, 208, 217, 232, 245, 249}

func (i scannerMetric) String() string {
	if i >= scannerMetric(len(_scannerMetric_index)-1) {

	Type uint16
	Data []byte
}

type echConfig struct {
	raw []byte

	Version uint16
	Length  uint16

	ConfigID             uint8
	KemID                uint16
	PublicKey            []byte
	SymmetricCipherSuite []echCipher

	MaxNameLength uint8
	PublicName    []byte
	Extensions    []echExtension
}

var errMalformedECHConfig = errors.New("tls: malformed ECHConfigList")

		return fmt.Sprintf("X%d", r-REG_X0)
	case REG_F0 <= r && r <= REG_F31:
		return fmt.Sprintf("F%d", r-REG_F0)
	default:
		return fmt.Sprintf("Rgok(%d)", r-obj.RBaseRISCV)
	}
}

func opSuffixString(s uint8) string {
	if s&rmSuffixBit == 0 {
		return ""
	}

	ss, err := rmSuffixString(s)
	if err != nil {
		ss = fmt.Sprintf("<invalid 0x%x>", s)
	}
	if ss == "" {
		return ss
	}

// shell variable such as $*.
func isShellSpecialVar(c uint8) bool {
	switch c {
	case '*', '#', '$', '@', '!', '?', '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
		return true
	}
	return false
}

// isAlphaNum reports whether the byte is an ASCII letter, number, or underscore.
func isAlphaNum(c uint8) bool {
	return c == '_' || '0' <= c && c <= '9' || 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z'

const (
	PathSeparator     = '/' // OS-specific path separator
	PathListSeparator = ':' // OS-specific path list separator
)

// IsPathSeparator reports whether c is a directory separator character.
func IsPathSeparator(c uint8) bool {
	return PathSeparator == c
}

// splitPath returns the base name and parent directory.
func splitPath(path string) (string, string) {
	// if no better parent is found, the path is relative from "here"

//
//go:generate msgp -unexported -file=$GOFILE
//go:generate stringer -type=Op -output=msg_string.go -trimprefix=Op $GOFILE

// Op is operation type messages.
type Op uint8

// HandlerID is the ID for the handler of a specific type.
type HandlerID uint8

const (
	// OpConnect is a connect request.
	OpConnect Op = iota + 1

	// OpConnectResponse is a response to a connect request.
	OpConnectResponse

		}
	}
}

// testMinMax tests that min/max behave correctly on every pair of
// values in vals.
//
// vals should be a sequence of values in strictly ascending order.
func testMinMax[T int | uint8 | string](t *testing.T, vals ...T) {
	for i, x := range vals {
		for _, y := range vals[i+1:] {
			if !(x < y) {
				t.Fatalf("values out of order: !(%v < %v)", x, y)
			}

			if z := min(x, y); z != x {