// Ceil computes the ceiling (next highest integer) of a signal.
489132
func (c C) Ceil() Input {
	return C(float32(math.Ceil(float64(c))))
}
1195331
func (ci CellID) Level() int {
	// Fast path for leaf cells.
	if ci.IsLeaf() {
		return maxLevel
	}
	x := uint32(ci)
	level := -1
	if x != 0 {
		level += 16
	} else {
		x = uint32(uint64(ci) >> 32)
	}
	// Only need to look at even-numbered bits for valid cell IDs.
	x &= -x // remove all but the LSB.
	if x&0x00005555 != 0 {
		level += 8
	}
	if x&0x00550055 != 0 {
		level += 4
	}
	if x&0x05050505 != 0 {
		level += 2
	}
	if x&0x11111111 != 0 {
		level += 1
	}
	return level
}
534012
func (s *StructStruct) CallUntil(m string, args []interface{}, until func([]interface{}) bool) ([]interface{}, bool) {
	res, ok := s.Call(m, args)
	if ok && until(res) {
		return res, true
	}
	for _, item := range s.data {
		if item.embedded == nil {
			continue
		}
		res, ok := item.embedded.CallUntil(m, args, until)
		if ok && until(res) {
			return res, true
		}
	}
	return nil, false
}
998188
func (s *Permission) SetLevel(v string) *Permission {
	s.Level = &v
	return s
}
640147
func (s *SkeinMac) DoFinal() (hash []byte) {
    hash = s.skein.DoFinal()
    s.Reset()
    return
}
1085251
func percentile(
	vals sort.IntSlice,
	n int) (x int) {
	// Special cases.
	switch {
	case n == 0:
		x = vals[0]
		return

	case n == 100:
		x = vals[len(vals)-1]
		return
	}

	// Find the nearest, truncating (why not).
	index := int((float64(n) / 100) * float64(len(vals)))
	x = vals[index]

	return
}
627877
func (d *Decoder) readUntil(sep byte) {
	for {
		b := d.readByte()
		if b == sep {
			return
		}
		d.buf.WriteByte(b)
	}
}
692791
func (s *Selection) NextUntil(selector string) *Selection {
	return pushStack(s, getSiblingNodes(s.Nodes, siblingNextUntil,
		compileMatcher(selector), nil))
}
1111965
func (c C) Floor() Input {
	return C(float32(math.Floor(float64(c))))
}
214010
func (r RedisPipeline) HDel(key string, fields ...string) *redis.IntCmd {
	return r.pipeline.HDel(key, fields...)
}
419756
func (s *Skein) DoFinal() (hash []byte) {
	hash = s.finalIntern()
	s.Reset()
	return
}
819307
func ceilFrac(numerator, denominator int64) (ceil int64) {
	if denominator == 0 {
		// do nothing on invalid input
		return
	}
	// Make denominator positive
	if denominator < 0 {
		numerator = -numerator
		denominator = -denominator
	}
	ceil = numerator / denominator
	if numerator > 0 && numerator%denominator != 0 {
		ceil++
	}
	return
}
348727
func percentile(orderedObservations []float64, l int, p float64) float64 {
	return orderedObservations[int(p*float64(l))]
}
1028088
func GetLevel() Level {
	std.mu.Lock()
	defer std.mu.Unlock()
	return std.Level
}
882048
func CeilToPowerOfTwo(n int) int {
	if n&maxintHeadBit != 0 && n > maxintHeadBit {
		panic("argument is too large")
	}
	if n <= 2 {
		return n
	}
	n--
	n = fillBits(n)
	n++
	return n
}
281341
func (as ArraySpec) Ceil() Input {
	return as.proc(func(i Input) Input {
		return i.Ceil()
	})
}
823748
func visitLevel(l *level, depth int) int {
	if l == nil || l.numNodes() == 0 {
		return depth
	}

	depth++
	maxDepth := depth

	for _, n := range l.nodes {
		if n == nil {
			continue
		}
		newDepth := visitLevel(n.next, depth)
		if newDepth > maxDepth {
			maxDepth = newDepth
		}
	}
	if l.pwc != nil {
		pwcDepth := visitLevel(l.pwc.next, depth)
		if pwcDepth > maxDepth {
			maxDepth = pwcDepth
		}
	}
	if l.fwc != nil {
		fwcDepth := visitLevel(l.fwc.next, depth)
		if fwcDepth > maxDepth {
			maxDepth = fwcDepth
		}
	}
	return maxDepth
}