// GetUint64 implements the Stable interface
197458
func (r *raftLog) GetUint64(k []byte) (uint64, error) {
	var v uint64
	vbytes, err := r.Get(k)
	if err == nil {
		v = binary.BigEndian.Uint64(vbytes)
	}
	return v, err
}
1169078
func (e *Entity) GetUint64(name string) (uint64, bool) {
	x, ok := e.Get(name).(uint64)
	return x, ok
}
200672
func (reader PluginConfigReaderWithError) GetUint(key string, defaultValue uint64) (uint64, error) {
	key = reader.config.registerKey(key)
	if reader.HasValue(key) {
		if strVal, err := reader.config.Settings.String(key); err == nil {
			return tstrings.AtoU64(strVal) // Allow string to number conversion
		}
		return reader.config.Settings.Uint(key)
	}
	return defaultValue, nil
}
740879
func (enc *Encoder) encodeUint64(n uint64) ([]byte, error) {
	enc.buf = strconv.AppendUint(enc.buf, n, 10)
	return enc.buf, nil
}
537561
func (e *GameEvent) GetUint64(name string) (uint64, error) {
	// Get the key from the message
	k, err := e.getEventKey(name)
	if err != nil {
		return 0, err
	}

	// Make sure it's a uint64.
	if k.GetType() != gameEventTypeUint64 {
		return 0, _errorf("field %s: expected uint64, got %s", name, gameEventTypeNames[k.GetType()])
	}

	return k.GetValUint64(), nil
}
460847
func (dec *Decoder) Uint64(v *uint64) error {
	err := dec.decodeUint64(v)
	if err != nil {
		return err
	}
	dec.called |= 1
	return nil
}
1006408
func PutUint64(b []byte, v uint64) {
	if l := len(b); l != 8 {
		panic(fmt.Sprintf("PutUint64: unexpected byte slice length: %d", l))
	}

	*(*uint64)(unsafe.Pointer(&b[0])) = v
}
581345
func (p *Params) MustUint64(key string, defaults ...uint64) uint64 {
	r, err := strconv.ParseUint(p.Get(key), 10, 64)
	if len(defaults) > 0 && err != nil {
		return defaults[0]
	}
	return r
}
1217143
func GetUintBytes(buf []byte, u uint64) []byte {
	if u == 0 {
		return []byte{'0'}
	}
	off := len(buf)
	var q, p uint64
	for u >= 100 {
		q = u / 1000
		p = (u - (q * 1000)) * 3
		u = q
		off -= 3
		buf[off] = digit3[p]
		buf[off+1] = digit3[p+1]
		buf[off+2] = digit3[p+2]
	}
	if u >= 10 {
		q = u / 100
		p = (u - (q * 100)) * 2
		u = q
		off -= 2
		buf[off] = digit2[p]
		buf[off+1] = digit2[p+1]
	}
	if u > 0 {
		off--
		buf[off] = digits[u]
	}
	return buf[off:]
}
1168668
func (r *Store) GetUint32(key string) (uint32, error) {
	v, ok := r.GetEntry(key)
	if !ok {
		return 0, errFindParse.Format("uint32", key)
	}
	return v.Uint32Default(0)
}
489340
func NewUint64(val uint64, p *uint64) *Uint64 {
	*p = val
	return (*Uint64)(p)
}
549960
func ReverseUint64(v uint64) (x uint64) {
	x |= uint64(ReverseLUT[byte(v>>0)]) << 56
	x |= uint64(ReverseLUT[byte(v>>8)]) << 48
	x |= uint64(ReverseLUT[byte(v>>16)]) << 40
	x |= uint64(ReverseLUT[byte(v>>24)]) << 32
	x |= uint64(ReverseLUT[byte(v>>32)]) << 24
	x |= uint64(ReverseLUT[byte(v>>40)]) << 16
	x |= uint64(ReverseLUT[byte(v>>48)]) << 8
	x |= uint64(ReverseLUT[byte(v>>56)]) << 0
	return x
}
1260803
func (tag PluginStructTag) GetUint() uint64 {
	tagValue, tagSet := reflect.StructTag(tag).Lookup(PluginStructTagDefault)
	if !tagSet || len(tagValue) == 0 {
		return 0
	}

	value, err := tstrings.AtoU64(tagValue)
	if err != nil {
		panic(err)
	}
	return value
}
252841
func MustDecodeUint64(input string) uint64 {
	dec, err := DecodeUint64(input)
	if err != nil {
		panic(err)
	}
	return dec
}
69057
func (r *Store) GetUint64(key string) (uint64, error) {
	v, ok := r.GetEntry(key)
	if !ok {
		return 0, errFindParse.Format("uint64", key)
	}
	return v.Uint64Default(0)
}
788082
func (hdr *rpmHeader) GetUint64s(tag int) ([]uint64, error) {
	buf, n, err := hdr.getInts(tag)
	if err != nil {
		return nil, err
	}
	if out, ok := buf.([]uint64); ok {
		return out, nil
	}
	out := make([]uint64, n)
	switch bvals := buf.(type) {
	case []uint8:
		for i, v := range bvals {
			out[i] = uint64(v)
		}
	case []uint16:
		for i, v := range bvals {
			out[i] = uint64(v)
		}
	case []uint32:
		for i, v := range bvals {
			out[i] = uint64(v)
		}
	}
	return out, nil
}
807506
func (enc *Encoder) EncodeUint64(n uint64) error {
	if enc.isPooled == 1 {
		panic(InvalidUsagePooledEncoderError("Invalid usage of pooled encoder"))
	}
	_, _ = enc.encodeUint64(n)
	_, err := enc.Write()
	if err != nil {
		return err
	}
	return nil
}