// RegEx matches only numeric values
var numericPlaceholderRe = regexp.MustCompile(`\$\d+\$`)

func isNumeric(k reflect.Kind) bool {
	switch k {
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		return true
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		return true
	case reflect.Float32, reflect.Float64:
		return true
	default:
		return false
	}
}

			for v := range s {
				if v.Uint() != i {
					t.Fatalf("got %d, want %d", v.Uint(), i)
				}
				i++
			}
			if i != 4 {
				t.Fatalf("should loop four times")
			}
		}},
		{"uint8", ValueOf(uint8(4)), func(t *testing.T, s iter.Seq[Value]) {
			i := uint8(0)
			for v := range s {
				if v.Interface().(uint8) != i {
					t.Fatalf("got %d, want %d", v.Int(), i)
				}
				i++
			}
			if i != 4 {

			if src, ok := c.LocalAddr().(*UDPAddr); ok {
				srcs[i], _ = netip.AddrFromSlice(src.IP)
			}
			c.Close()
		}
	}
	return srcs
}

type ipAttr struct {
	Scope      scope
	Precedence uint8
	Label      uint8
}

func ipAttrOf(ip netip.Addr) ipAttr {
	if !ip.IsValid() {
		return ipAttr{}
	}
	match := rfc6724policyTable.Classify(ip)
	return ipAttr{
		Scope:      classifyScope(ip),

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

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

)

type Winsize struct {
	Row    uint16
	Col    uint16
	Xpixel uint16
	Ypixel uint16
}

type Termios struct {
	Iflag  uint32
	Oflag  uint32
	Cflag  uint32
	Lflag  uint32
	Cc     [20]uint8
	Ispeed int32
	Ospeed int32

// RUN: stablehlo-quant-opt %s -quant-convert-tf-quant-ops-to-mhlo | FileCheck %s

// CHECK-LABEL: func @quantized_matmul_fn
func.func @quantized_matmul_fn(%input: tensor<?x?xf32>) -> tensor<?x?xf32> {

	}

	randutil.MaybeReadByte(rand)

	b := uint(bits % 8)
	if b == 0 {
		b = 8
	}

	bytes := make([]byte, (bits+7)/8)
	p := new(big.Int)

	for {
		if _, err := io.ReadFull(rand, bytes); err != nil {
			return nil, err
		}

		// Clear bits in the first byte to make sure the candidate has a size <= bits.
		bytes[0] &= uint8(int(1<<b) - 1)

	_ = x[batchJobMetricReplication-0]
	_ = x[batchJobMetricKeyRotation-1]
	_ = x[batchJobMetricExpire-2]
}

const _batchJobMetric_name = "ReplicationKeyRotationExpire"

var _batchJobMetric_index = [...]uint8{0, 11, 22, 28}

func (i batchJobMetric) String() string {
	if i >= batchJobMetric(len(_batchJobMetric_index)-1) {
		return "batchJobMetric(" + strconv.FormatInt(int64(i), 10) + ")"
	}

func (z WalkVersionsSortOrder) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	o = msgp.AppendUint8(o, uint8(z))
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *WalkVersionsSortOrder) UnmarshalMsg(bts []byte) (o []byte, err error) {
	{
		var zb0001 uint8
		zb0001, bts, err = msgp.ReadUint8Bytes(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}

type RoutingMessage interface {
	sockaddr() ([]Sockaddr, error)
}

const anyMessageLen = int(unsafe.Sizeof(anyMessage{}))

type anyMessage struct {
	Msglen  uint16
	Version uint8
	Type    uint8
}

// RouteMessage represents a routing message containing routing
// entries.
//
// Deprecated: Use golang.org/x/net/route instead.
type RouteMessage struct {
	Header RtMsghdr
	Data   []byte