// RotateLeft64 rotate an 64-bit value left
428498
func RotateLeft64(value uint64, shift uint) (uint64){
    shift = shift & 0x3F

    return (value << shift) | (value >> (64 - shift))
}
344646
func (mmap MarshalMap) Int64Slice(key string) ([]int64, error) {
	return mmap.Int64Array(key)
}
344670
func (r *Rand) Float64() float64 {
	// A clearer, simpler implementation would be:
	//	return float64(Int63n(1<<53)) / (1<<53)
	// However, Go 1 shipped with
	//	return float64(Int63()) / (1 << 63)
	// and we want to preserve that value stream.
	//
	// There is one bug in the value stream: Int63() may be so close
	// to 1<<63 that the division rounds up to 1.0, and we've guaranteed
	// that the result is always less than 1.0. To fix that, we treat the
	// range as cyclic and map 1 back to 0. This is justified by observing
	// that while some of the values rounded down to 0, nothing was
	// rounding up to 0, so 0 was underrepresented in the results.
	// Mapping 1 back to zero restores some balance.
	// (The balance is not perfect because the implementation
	// returns denormalized numbers for very small Int63(),
	// and those steal from what would normally be 0 results.)
	// The remapping only happens 1/2⁵³ of the time, so most clients
	// will not observe it anyway.
	f := float64(r.Int63()) / (1 << 63)
	if f == 1 {
		f = 0
	}
	return f
}
1326510
func (dec *Decoder) SQLNullInt64(v *sql.NullInt64) error {
	var b *int64
	if err := dec.Int64Null(&b); err != nil {
		return err
	}
	if b == nil {
		v.Valid = false
	} else {
		v.Int64 = *b
		v.Valid = true
	}
	return nil
}
1301288
func ToUint64(n uint64) [8]byte {
	s := make([]byte, 8)
	binary.LittleEndian.PutUint64(s, n)
	a := [8]byte{}
	copy(a[:], s[:8])
	return a
}
1198486
func (p *parserMixin) Float64() (target *float64) {
	target = new(float64)
	p.Float64Var(target)
	return
}
581708
func UInt64() (i uint64) {
	randomBits(r)
	buf := bytes.NewBuffer(r)
	binary.Read(buf, binary.LittleEndian, &i)
	return i
}
1105560
func (rwops *RWops) ReadLE64() uint64 {
	if rwops == nil {
		return 0
	}
	return uint64(C.SDL_ReadLE64(rwops.cptr()))
}
632361
func (dec *Decoder) Int64(v *int64) error {
	err := dec.decodeInt64(v)
	if err != nil {
		return err
	}
	dec.called |= 1
	return nil
}
563385
func (f *Filter) readFullUint64(b *bstream.BStream) (uint64, error) {
	var quotient uint64

	// Count the 1s until we reach a 0.
	c, err := b.ReadBit()
	if err != nil {
		return 0, err
	}
	for c {
		quotient++
		c, err = b.ReadBit()
		if err != nil {
			return 0, err
		}
	}

	// Read P bits.
	remainder, err := b.ReadBits(int(f.p))
	if err != nil {
		return 0, err
	}

	// Add the multiple and the remainder.
	v := (quotient << f.p) + remainder
	return v, nil
}
667433
func (lr *LockedRand) Uint64() (n uint64) {
	lr.lk.Lock()
	n = lr.r.Uint64()
	lr.lk.Unlock()
	return
}
865790
func ReverseFloat64(s []float64) []float64 {
	for i, j := 0, len(s)-1; i < len(s)/2; i, j = i+1, j-1 {
		s[i], s[j] = s[j], s[i]
	}
	return s
}
1011462
func (s *SimpleStyledTextBar) SetLeft(m string) {
	s.initialize()
	s.left.SetMarkup(m)
}
752690
func (writer *ConsoleWriter) RotateLines() int {
	writer.lock.RLock()
	defer writer.lock.RUnlock()

	return 0
}
1116108
func (k *Key) InUint64(defaultVal uint64, candidates []uint64) uint64 {
	val := k.MustUint64()
	for _, cand := range candidates {
		if val == cand {
			return val
		}
	}
	return defaultVal
}
818524
func RotateRight(x uint, k int) uint {
	if UintSize == 32 {
		return uint(RotateRight32(uint32(x), k))
	}
	return uint(RotateRight64(uint64(x), k))
}
55276
func (context *BaseContext) SetUInt64(key string, value uint64) {
	context.userData[key] = value
}