return nil, errors.New("xlMetaInlineData: unknown version")
	}

	sz, buf, e := msgp.ReadMapHeaderBytes(x.afterVersion())
	if e != nil {
		return nil, e
	}
	res := []byte("{")

	for i := uint32(0); i < sz; i++ {
		var key, val []byte
		key, buf, e = msgp.ReadMapKeyZC(buf)
		if e != nil {
			return nil, e
		}
		if len(key) == 0 {
			return nil, fmt.Errorf("xlMetaInlineData: key %d is length 0", i)

	}
	info.Used = info.Total - info.Free
	return info, nil
}

// GetDriveStats returns IO stats of the drive by its major:minor
func GetDriveStats(major, minor uint32) (iostats IOStats, err error) {
	return IOStats{}, errors.New("operation unsupported")

	// parameters describe the desired read segment. When
	// `isFromEnd` is true, `skipLen` argument is ignored.
	decryptedRangeRef := func(s []int64, skipLen, readLen int64, isFromEnd bool) (o, l, skip int64, sn uint32, ps int) {
		oSize := lsum(s)
		if isFromEnd {
			skipLen = oSize - readLen
		}
		if skipLen < 0 || readLen < 0 || oSize < 0 || skipLen+readLen > oSize {

)

// ListenerFilter is used to pass filter information into listener based config writer print functions
type ListenerFilter struct {
	Address string
	Port    uint32
	Type    string
	Verbose bool
}

// Verify returns true if the passed listener matches the filter fields
func (l *ListenerFilter) Verify(listener *listener.Listener) bool {

	Weight   int         `json:"weight,omitempty"`
	Text     string      `json:"text,omitempty"`
	Mail     bool        `json:"mail,omitempty"` // Be an MX record. Priority becomes Preference.
	TTL      uint32      `json:"ttl,omitempty"`

	// Holds info about when the entry was created first.
	CreationDate time.Time `json:"creationDate"`

	// When a SRV record with a "Host: IP-address" is added, we synthesize

	if v, ok := mountPointCache.Load(path); ok {
		return v.(bool)
	}
	wpath, _ := windows.UTF16PtrFromString(path)
	wvolume := make([]uint16, len(path)+1)

	if err := windows.GetVolumePathName(wpath, &wvolume[0], uint32(len(wvolume))); err != nil {
		mountPointCache.Store(path, false)
		return false
	}

	switch windows.GetDriveType(&wvolume[0]) {

		inpodMarkRule := netlink.NewRule()
		inpodMarkRule.Family = family
		inpodMarkRule.Table = RouteTableInbound
		inpodMarkRule.Mark = InpodTProxyMark
		inpodMarkRule.Mask = ptr.Of(uint32(InpodTProxyMask))
		inpodMarkRule.Priority = 32764
		rules = append(rules, inpodMarkRule)
	}

	for _, rule := range rules {
		log.Debugf("processing netlink rule: %+v", rule)
		if err := f(rule); err != nil {

pkg syscall (freebsd-arm64), type Termios struct, Cflag uint32
pkg syscall (freebsd-arm64), type Termios struct, Iflag uint32
pkg syscall (freebsd-arm64), type Termios struct, Ispeed uint32
pkg syscall (freebsd-arm64), type Termios struct, Lflag uint32
pkg syscall (freebsd-arm64), type Termios struct, Oflag uint32
pkg syscall (freebsd-arm64), type Termios struct, Ospeed uint32
pkg syscall (freebsd-arm64), type Timespec struct, Nsec int64

			db.AddError(rows.Scan(values...))

			mapValue := map[string]interface{}{}
			scanIntoMap(mapValue, values, columns)
			*dest = append(*dest, mapValue)
		}
	case *int, *int8, *int16, *int32, *int64,
		*uint, *uint8, *uint16, *uint32, *uint64, *uintptr,
		*float32, *float64,
		*bool, *string, *time.Time,
		*sql.NullInt32, *sql.NullInt64, *sql.NullFloat64,
		*sql.NullBool, *sql.NullString, *sql.NullTime:

	}
	return iSpec, nil
}

func convertToUnsignedInt32Map(s []string) map[string]uint32 {
	out := make(map[string]uint32, len(s))
	for _, l := range s {
		k, v := splitEqual(l)
		u64, err := strconv.ParseUint(v, 10, 32)
		if err != nil {
			log.Errorf("failed to convert to uint32: %v", err)
		}
		out[k] = uint32(u64)
	}
	return out
}

func convertToStringMap(s []string) map[string]string {