// UIntShrinker is a shrinker for uint numbers
766357
func UIntShrinker(v interface{}) gopter.Shrink {
	return UInt64Shrinker(uint64(v.(uint))).Map(uint64ToUint)
}
228918
func StringShrinker(v interface{}) gopter.Shrink {
	return runeSliceShrinker([]rune(v.(string))).Map(runesToString)
}
942401
func (r *queryTable) UInts(j int) *array.Uint64 {
	return r.cols[j].(*array.Uint64)
}
1077624
func shiftHigher(bit byte, b []byte) byte {
	for i := 0; i < len(b); i++ {
		newByte := b[i] << 1
		newByte |= bit
		bit = (b[i] & 0x80) >> 7
		b[i] = newByte
	}
	return bit
}
1104136
func (v *VARIANT) ToIUnknown() *IUnknown {
	if v.VT != VT_UNKNOWN {
		return nil
	}
	return (*IUnknown)(unsafe.Pointer(uintptr(v.Val)))
}
667433
func (lr *LockedRand) Uint64() (n uint64) {
	lr.lk.Lock()
	n = lr.r.Uint64()
	lr.lk.Unlock()
	return
}
1282257
func MulInteger(a uint64, b int64) (uint64, error) {
	if a == 0 || b == 0 {
		return 0, nil
	}

	if b < 0 {
		return 0, errors.Trace(ErrArithOverflow)
	}

	return MulUint64(a, uint64(b))
}
1282285
func (p *siprng) Uint64() uint64 {
	p.mu.Lock()
	if p.ctr == 0 || p.ctr > 8*1024*1024 {
		p.rekey()
	}
	v := siphash(p.k0, p.k1, p.ctr)
	p.ctr++
	p.mu.Unlock()
	return v
}
165347
func MakeRangeCodes(minBase uint, bits []uint) (rc RangeCodes) {
	for _, nb := range bits {
		rc = append(rc, RangeCode{Base: uint32(minBase), Len: uint32(nb)})
		minBase += 1 << nb
	}
	return rc
}
1174590
func (p *parserMixin) Uint64() (target *uint64) {
	target = new(uint64)
	p.Uint64Var(target)
	return
}
1153900
func (c Context) Uints32(key string, i []uint32) Context {
	c.l.context = enc.AppendUints32(enc.AppendKey(c.l.context, key), i)
	return c
}
129715
func (a *Array) Uint(i uint) *Array {
	a.buf = enc.AppendUint(enc.AppendArrayDelim(a.buf), i)
	return a
}
508281
func Int16Shrinker(v interface{}) gopter.Shrink {
	return Int64Shrinker(int64(v.(int16))).Map(int64To16)
}
1269018
func (g *Group) Uint64() *Statement {
	// notest
	s := Uint64()
	g.items = append(g.items, s)
	return s
}
456807
func Uint64(v uint64) *uint64 {
	p := new(uint64)
	*p = v
	return p
}
586264
func (x *Big) Uint64() (uint64, bool) {
	if debug {
		x.validate()
	}

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

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

	b := x.compact
	if x.exp == 0 {
		return b, true
	}
	return scalex(b, x.exp)
}
150532
func uintAsBoolDecoder(dv, sv reflect.Value) error {
	dv.SetBool(sv.Uint() != 0)
	return nil
}