default:
			errorf("corrupted CommonType, delta is %d fieldNum is %d", delta, fieldNum)
		}
	}
	return CommonType{name, id}
}

// uint returns the unsigned int at the input point, as a uint (not uint64).
func (deb *debugger) uint() uint {
	return uint(deb.uint64())
}

// int returns the signed int at the input point, as an int (not int64).
func (deb *debugger) int() int {
	return int(deb.int64())
}

func TestIsInteger(t *testing.T) {
	tests := []struct {
		desc     string
		function func(v reflect.Kind) bool
		want     []any
	}{
		{
			desc:     "ints",
			function: IsIntKind,
			want:     allIntTypes,
		},
		{
			desc:     "uints",
			function: IsUintKind,
			want:     allUintTypes,
		},
	}

	for _, tt := range tests {
		var got []any
		for _, v := range allTypes {

type parseError struct{ text string }

func (e *parseError) Error() string { return e.text }

// FNV-1a implementation. See Go's hash/fnv/fnv.go.
// Copied here for simplicity (can handle uints directly)
// and to avoid the dependency.

const (
	offset64 uint64 = 14695981039346656037
	prime64  uint64 = 1099511628211
)

func fnv(h uint64, x byte) uint64 {
	h ^= uint64(x)
	h *= prime64

 *
 * @author Kevin Bourrillion
 * @since 1.0
 */
@GwtCompatible(emulated = true)
@ElementTypesAreNonnullByDefault
public final class Ints extends IntsMethodsForWeb {
  private Ints() {}

  /**
   * The number of bytes required to represent a primitive {@code int} value.
   *
   * <p><b>Java 8+ users:</b> use {@link Integer#BYTES} instead.
   */

 *
 * @author Kevin Bourrillion
 * @since 1.0
 */
@GwtCompatible(emulated = true)
@ElementTypesAreNonnullByDefault
public final class Ints extends IntsMethodsForWeb {
  private Ints() {}

  /**
   * The number of bytes required to represent a primitive {@code int} value.
   *
   * <p><b>Java 8+ users:</b> use {@link Integer#BYTES} instead.
   */

// from the default Source.
// It panics if n <= 0.
func IntN(n int) int { return globalRand.IntN(n) }

// UintN returns, as a uint, a pseudo-random number in the half-open interval [0,n)
// from the default Source.
// It panics if n <= 0.
func UintN(n uint) uint { return globalRand.UintN(n) }

// N returns a pseudo-random number in the half-open interval [0,n) from the default Source.

		var a abbrev
		a.tag = Tag(b.uint())
		a.children = b.uint8() != 0
		a.field = make([]afield, n)
		for i := range a.field {
			a.field[i].attr = Attr(b.uint())
			a.field[i].fmt = format(b.uint())
			a.field[i].class = formToClass(a.field[i].fmt, a.field[i].attr, vers, &b)
			if a.field[i].fmt == formImplicitConst {
				a.field[i].val = b.int()
			}
		}
		b.uint()
		b.uint()

		m[id] = a
	}

	uint64(8204908297817606218),  // Uint()
	uint64(17358349022401942459), // Uint()
	uint64(2240328155279531677),  // Uint()
	uint64(7311121042813227358),  // Uint()
	uint64(14454429957748299131), // Uint()
	uint64(13481244625344276711), // Uint()
	uint64(9381769212557126946),  // Uint()
	uint64(1350674201389090105),  // Uint()
	uint64(6093522341581845358),  // Uint()

	uint32(3304433030), // Uint32()

	{"%o", "075\n", &uintVal, uint(075)},
	{"%o", "07_5\n", &uintVal, uint(07)}, // only %v takes underscores
	{"%x", "a75\n", &uintVal, uint(0xa75)},
	{"%x", "A75\n", &uintVal, uint(0xa75)},
	{"%x", "A7_5\n", &uintVal, uint(0xa7)}, // only %v takes underscores
	{"%U", "U+1234\n", &intVal, int(0x1234)},
	{"%U", "U+4567\n", &uintVal, uint(0x4567)},

	{"%e", "2.3\n", &float64Val, 2.3},
	{"%E", "2.3e1\n", &float32Val, float32(2.3e1)},

pkg math/bits, func ReverseBytes(uint) uint
pkg math/bits, func ReverseBytes16(uint16) uint16
pkg math/bits, func ReverseBytes32(uint32) uint32
pkg math/bits, func ReverseBytes64(uint64) uint64
pkg math/bits, func RotateLeft(uint, int) uint
pkg math/bits, func RotateLeft16(uint16, int) uint16
pkg math/bits, func RotateLeft32(uint32, int) uint32
pkg math/bits, func RotateLeft64(uint64, int) uint64