// Entropy returns the entropy from the ULID.
432140
func (id ULID) Entropy() []byte {
	e := make([]byte, 10)
	copy(e, id[6:])
	return e
}
1144685
func Get8UUID() string {
	u1 := uuid.NewV4()
	str := fmt.Sprintf("%s", u1)
	return str[0:8]
}
261374
func AllUUID(u ble.UUID) Field {
	return func(p *Packet) error {
		if u.Len() == 2 {
			return p.append(allUUID16, u)
		}
		if u.Len() == 4 {
			return p.append(allUUID32, u)
		}
		return p.append(allUUID128, u)
	}
}
488617
func (z *Zone) InfoByUUID(uuid uuid.UUID) (info *Info, err error) {
	_, err = z.Get(fmt.Sprintf("/zones/%s", uuid), &info)
	if debug {
		fmt.Printf("DEBUG: InfoByUUID returned SharingID=%v domain=%v\n", info.SharingID, info.Name)
	}
	return
}
542986
func (ulid ULID) String() string {
	var (
		buf  [26]byte
		x, y byte
	)
	// Backups [6] and [7] bytes to override them with their original values later.
	x, y, ulid[6], ulid[7] = ulid[6], ulid[7], x, y
	timestamp := int64(binary.LittleEndian.Uint64(ulid[:8]))
	// This is useful to shave some nanoseconds from copy() operations.
	ulid[6], ulid[7] = x, y
	for x := encodedTimeLength - 1; x >= 0; x-- {
		mod := timestamp % alphabetSize
		buf[x] = alphabet[mod]
		timestamp = (timestamp - mod) / alphabetSize
	}
	for x := encodedTimeLength; x < len(ulid); x++ {
		buf[x] = alphabet[int64(ulid[x])%alphabetSize]
	}
	return string(buf[:])
}
76434
func (g *Generator) Int(lo, hi int) int {
	if lo == hi {
		return lo
	}
	if lo > hi {
		lo, hi = hi, lo
	}
	n := g.rand.Intn(hi - lo + 1)
	return lo + n
}
906749
func UUID() string {
	version := byte(4)
	uuid := make([]byte, 16)
	rand.Read(uuid)

	// Set version
	uuid[6] = (uuid[6] & 0x0f) | (version << 4)

	// Set variant
	uuid[8] = (uuid[8] & 0xbf) | 0x80

	buf := make([]byte, 36)
	var dash byte = '-'
	hex.Encode(buf[0:8], uuid[0:4])
	buf[8] = dash
	hex.Encode(buf[9:13], uuid[4:6])
	buf[13] = dash
	hex.Encode(buf[14:18], uuid[6:8])
	buf[18] = dash
	hex.Encode(buf[19:23], uuid[8:10])
	buf[23] = dash
	hex.Encode(buf[24:], uuid[10:])

	return string(buf)
}
621750
func (id ULID) Time() uint64 {
	return uint64(id[5]) | uint64(id[4])<<8 |
		uint64(id[3])<<16 | uint64(id[2])<<24 |
		uint64(id[1])<<32 | uint64(id[0])<<40
}
1366315
func RandomUUID() (UUID, error) {
	var u UUID
	_, err := io.ReadFull(rand.Reader, u[:])
	if err != nil {
		return u, err
	}
	u[6] &= 0x0F // clear version
	u[6] |= 0x40 // set version to 4 (random uuid)
	u[8] &= 0x3F // clear variant
	u[8] |= 0x80 // set to IETF variant
	return u, nil
}
1119302
func (l *logger) Info(format string, args ...interface{}) {
	if l.Level >= INFO {
		l.log(INFO, format, args...)
	}
}
34384
func (n *Node) UUID() uuid.UUID {
	var buffer bytes.Buffer
	buffer.WriteString(string(*n.t))
	buffer.WriteString(string(*n.id))
	return uuid.NewSHA1(uuid.NIL, buffer.Bytes())
}
938748
func (u UUID) Equal(v UUID) bool {
	return bytes.Equal(u.b, v.b)
}
464391
func (r *UtilService) Uuid() *UtilUuidCall {
	c := &UtilUuidCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	return c
}
867620
func complexity(fn *ast.FuncDecl) int {
	v := complexityVisitor{}
	ast.Walk(&v, fn)
	return v.Complexity
}
1050419
func (proxier *Proxier) probability(n int) string {
	if n >= len(proxier.precomputedProbabilities) {
		proxier.precomputeProbabilities(n)
	}
	return proxier.precomputedProbabilities[n]
}
766010
func NewEntropy(bitSize int) ([]byte, error) {
	err := validateEntropyBitSize(bitSize)
	if err != nil {
		return nil, err
	}

	entropy := make([]byte, bitSize/8)
	_, err = rand.Read(entropy)
	return entropy, err
}
658284
func (u UUID) Equal(o UUID) bool {
	return bytes.Equal(u, o)
}