// MustInt64 reads int64 from config file, panic if file not exists or data can not parse to int64
543715
func (r *Reader) MustInt64(name string) int64 {
	i, err := r.readInt64(name)
	if err != nil {
		panic(err)
	}
	return i
}
1175620
func (c Context) Int64(key string, i int64) Context {
	c.l.context = enc.AppendInt64(enc.AppendKey(c.l.context, key), i)
	return c
}
1019332
func (f *Queries) MustFloat64(key string, defaults ...float64) float64 {
	if v, ok := f.Values()[key]; ok {
		i, err := strconv.ParseFloat(v[0], 64)
		if err == nil {
			return i
		}
	}
	if len(defaults) > 0 {
		return defaults[0]
	}
	return 0
}
252841
func MustDecodeUint64(input string) uint64 {
	dec, err := DecodeUint64(input)
	if err != nil {
		panic(err)
	}
	return dec
}
1358577
func MustAbsInt64(n int64) int64 {
	if n == -1<<63 {
		panic("value out of range")
	}
	y := n >> 63       // y ← x ⟫ 63
	return (n ^ y) - y // (x ⨁ y) - y
}
1063310
func (f *Queries) MustInt(key string, defaults ...int) int {
	if v, ok := f.Values()[key]; ok {
		i, err := strconv.Atoi(v[0])
		if err == nil {
			return i
		}
	}
	if len(defaults) > 0 {
		return defaults[0]
	}
	return 0
}
1135476
func (f *Queries) Int64(key string) (int64, error) {
	s, err := f.String(key)
	if err != nil {
		return 0, err
	}
	v, err := strconv.ParseInt(s, 10, 64)
	return v, err
}
387203
func MustParse(s string) int64 {
	i, err := ParseBytesPerKB(s, 0 /*autodetect*/)
	if err != nil {
		panic(err)
	}
	return i
}
638612
func MustReadVarInt64(r io.Reader) int64 {
	i64, err := ReadVarInt64(r)
	if err != nil {
		panic(err)
	}
	return i64
}
306558
func (r *Reader) MustInt(name string) int {
	i, err := r.readInt(name)
	if err != nil {
		panic(err)
	}
	return i
}
853057
func (x *Big) Int64() (int64, bool) {
	if debug {
		x.validate()
	}

	if !x.IsFinite() {
		return 0, false
	}

	// x might be too large to fit into an int64 *now*, but rescaling x might
	// shrink it enough. See issue #20.
	if !x.isCompact() {
		xb := x.Int(nil)
		return xb.Int64(), xb.IsInt64()
	}

	u := x.compact
	if x.exp != 0 {
		var ok bool
		if u, ok = scalex(u, x.exp); !ok {
			return 0, false
		}
	}
	su := int64(u)
	if su >= 0 || x.Signbit() && su == -su {
		if x.Signbit() {
			su = -su
		}
		return su, true
	}
	return 0, false
}
50639
func (f *Queries) MustUint64(key string, defaults ...uint64) uint64 {
	if v, ok := f.Values()[key]; ok {
		i, err := strconv.ParseUint(v[0], 10, 64)
		if err == nil {
			return i
		}
	}
	if len(defaults) > 0 {
		return defaults[0]
	}
	return 0
}
670306
func (env *Env) SetInt64(key string, value int64) {
	env.Set(key, strconv.FormatInt(value, 10))
}
1040118
func (j *Json) MustInt64(args ...int64) int64 {
	var def int64

	switch len(args) {
	case 0:
	case 1:
		def = args[0]
	default:
		log.Panicf("MustInt64() received too many arguments %d", len(args))
	}

	i, err := j.Int64()
	if err == nil {
		return i
	}

	return def
}
338663
func (ec *Envcfg) MustInt(key string) int {
	val := ec.MustKey(key)
	i, err := strconv.Atoi(val)
	if err != nil {
		panic(fmt.Sprintf("key %s must be a valid int", key))
	}
	return i
}
1086695
func Int64(short string, long string, value int64, usage string) *int64 {
	flagVar := value
	return Int64Var(&flagVar, short, long, value, usage)
}
462031
func (f *Forms) MustInt64(key string, defaults ...int64) int64 {
	v, err := strconv.ParseInt((*http.Request)(f).FormValue(key), 10, 64)
	if len(defaults) > 0 && err != nil {
		return defaults[0]
	}
	return v
}