// OrElse returns the int8 value or a default value if the value is not present.
335829
func (i Int8) OrElse(v int8) int8 {
	if i.Present() {
		return *i.value
	}
	return v
}
1086615
func (e Error) OrElse(v error) error {
	if e.Present() {
		return *e.value
	}
	return v
}
1130833
func (lt *lt) OrdinalPluralRule(num float64, v uint64) locales.PluralRule {
	return locales.PluralRuleOther
}
141474
func isLte(fl FieldLevel) bool {

	field := fl.Field()
	param := fl.Param()

	switch field.Kind() {

	case reflect.String:
		p := asInt(param)

		return int64(utf8.RuneCountInString(field.String())) <= p

	case reflect.Slice, reflect.Map, reflect.Array:
		p := asInt(param)

		return int64(field.Len()) <= p

	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		p := asInt(param)

		return field.Int() <= p

	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
		p := asUint(param)

		return field.Uint() <= p

	case reflect.Float32, reflect.Float64:
		p := asFloat(param)

		return field.Float() <= p

	case reflect.Struct:

		if field.Type() == timeType {

			now := time.Now().UTC()
			t := field.Interface().(time.Time)

			return t.Before(now) || t.Equal(now)
		}
	}

	panic(fmt.Sprintf("Bad field type %T", field.Interface()))
}
942457
func (chr *chr_US) OrdinalPluralRule(num float64, v uint64) locales.PluralRule {
	return locales.PluralRuleUnknown
}
440980
func (b *builtinPISig) evalReal(_ chunk.Row) (float64, bool, error) {
	return float64(math.Pi), false, nil
}
139596
func Int8Range(min, max int8) gopter.Gen {
	return Int64Range(int64(min), int64(max)).
		Map(int64To8).
		WithShrinker(Int8Shrinker).
		SuchThat(func(v int8) bool {
			return v >= min && v <= max
		})
}
1097930
func (gl *gl) OrdinalPluralRule(num float64, v uint64) locales.PluralRule {
	return locales.PluralRuleOther
}
104373
func (e *Ethtool) MsglvlSet(intf string, valset uint32) (uint32, uint32, error) {
	edata := ethtoolValue{
		cmd: ETHTOOL_GMSGLVL,
	}

	var name [IFNAMSIZ]byte
	copy(name[:], []byte(intf))

	ifr := ifreq{
		ifr_name: name,
		ifr_data: uintptr(unsafe.Pointer(&edata)),
	}

	_, _, ep := syscall.Syscall(syscall.SYS_IOCTL, uintptr(e.fd),
		SIOCETHTOOL, uintptr(unsafe.Pointer(&ifr)))
	if ep != 0 {
		return 0, 0, syscall.Errno(ep)
	}

	readval := edata.data

	edata.cmd = ETHTOOL_SMSGLVL
	edata.data = valset

	_, _, ep = syscall.Syscall(syscall.SYS_IOCTL, uintptr(e.fd),
		SIOCETHTOOL, uintptr(unsafe.Pointer(&ifr)))
	if ep != 0 {
		return 0, 0, syscall.Errno(ep)
	}

	return readval, edata.data, nil
}
990518
func (c Complex64) OrElse(v complex64) complex64 {
	if c.Present() {
		return *c.value
	}
	return v
}
1176174
func (si *si) OrdinalPluralRule(num float64, v uint64) locales.PluralRule {
	return locales.PluralRuleOther
}
584379
func (n *FilteredString) ParseValue(val string) {
	if val == "" {
		n.IsSet = false
		n.Value = ""
		return
	}

	n.IsSet = true

	switch val {
	case "null", "default":
		n.Value = ""
	default:
		n.Value = val
	}
}
38807
func (he *he_IL) OrdinalPluralRule(num float64, v uint64) locales.PluralRule {
	return locales.PluralRuleOther
}
921983
func (u Uint64) OrElse(v uint64) uint64 {
	if u.Present() {
		return *u.value
	}
	return v
}
830525
func (b *builtinDegreesSig) evalReal(row chunk.Row) (float64, bool, error) {
	val, isNull, err := b.args[0].EvalReal(b.ctx, row)
	if isNull || err != nil {
		return 0, isNull, err
	}
	res := val * 180 / math.Pi
	return res, false, nil
}
1375029
func (f Float64) OrElse(v float64) float64 {
	if f.Present() {
		return *f.value
	}
	return v
}
777665
func (u Uint8) OrElse(v uint8) uint8 {
	if u.Present() {
		return *u.value
	}
	return v
}