// Decr is just Count of -1
324008
func (c *Client) Decr(name string, tags []string, rate float64) error {
	return c.send(name, nil, decrSuffix, tags, rate)
}
283976
func (r refCount) Decrement(key string) int {
	val := r[key]
	if val <= 1 {
		delete(r, key)
		return 0
	}
	r[key]--
	return r[key]
}
267820
func (r *RateCounter) Incr(val int64) {
	r.counter.Incr(val)
	r.partials[atomic.LoadInt32(&r.current)].Incr(val)
	r.run()
}
1325886
func (o *Buffer) dec_ref_int32(p *Properties, base structPointer) error {
	u, err := p.valDec(o)
	if err != nil {
		return err
	}
	refWord32_Set(structPointer_RefWord32(base, p.field), o, uint32(u))
	return nil
}
442516
func (o *Buffer) dec_ref_string(p *Properties, base structPointer) error {
	s, err := o.DecodeStringBytes()
	if err != nil {
		return err
	}
	*structPointer_RefString(base, p.field) = s
	return nil
}
278758
func cpIncr(bz []byte) (ret []byte) {
	if len(bz) == 0 {
		panic("cpIncr expects non-zero bz length")
	}
	ret = cp(bz)
	for i := len(bz) - 1; i >= 0; i-- {
		if ret[i] < byte(0xFF) {
			ret[i]++
			return
		}
		ret[i] = byte(0x00)
		if i == 0 {
			// Overflow
			return nil
		}
	}
	return nil
}
1113001
func (c *Client) Incr(key string, delta, init uint64, exp uint32, ocas uint64) (n, cas uint64, err error) {
	return c.incrdecr(opIncrement, key, delta, init, exp, ocas)
}
339407
func declToken(decl ast.Decl) (tok token.Token) {
	tok = token.ILLEGAL
	switch d := decl.(type) {
	case *ast.GenDecl:
		tok = d.Tok
	case *ast.FuncDecl:
		tok = token.FUNC
	}
	return
}
80357
func (c *RefCount) DecReads() {
	tracebackEvent(c, c.NumRef(), decReadsEvent)
	n := atomic.AddInt32(&c.reads, -1)

	if ref := c.NumRef(); ref < 1 {
		err := fmt.Errorf("read finish after free: reads=%d, ref=%d", n, ref)
		panicRef(c, err)
	}
}
1275861
func (c *syncClient) Decrby(arg0 string, arg1 int64) (result int64, err Error) {
	arg0bytes := []byte(arg0)
	arg1bytes := []byte(fmt.Sprintf("%d", arg1))

	var resp Response
	resp, err = c.conn.ServiceRequest(&DECRBY, [][]byte{arg0bytes, arg1bytes})
	if err == nil {
		result = resp.GetNumberValue()
	}
	return result, err

}
534885
func (f *simpleField) decl(g *Generator, mc *msgCtx) {
	g.P(f.comment, Annotate(mc.message.file, f.fullPath, f.goName), "\t", f.goType, "\t`", f.tags, "`", f.deprecated)
}
10257
func cpIncr(bz []byte) (ret []byte) {
	ret = cp(bz)
	for i := len(bz) - 1; i >= 0; i-- {
		if ret[i] < byte(0xFF) {
			ret[i]++
			return
		}
		ret[i] = byte(0x00)
		if i == 0 {
			return append(ret, 0x00)
		}
	}
	return []byte{0x00}
}
845254
func (c *Client) DecrBy(key string, decrement int) (int, error) {
	v, err := c.execWithKey(true, "DECRBY", key, decrement)
	if err != nil {
		return 0, err
	}
	return iface2int(v)
}
531513
func (r *Redis) DecrBy(key string, decrement int) (int64, error) {
	rp, err := r.ExecuteCommand("DECRBY", key, decrement)
	if err != nil {
		return 0, err
	}
	return rp.IntegerValue()
}
924164
func Rocr(real []float64, timePeriod int32) []float64 {
	var outBegIdx C.int
	var outNBElement C.int
	outReal := make([]float64, len(real))
	C.TA_ROCR(0, C.int(len(real)-1), (*C.double)(unsafe.Pointer(&real[0])), C.int(timePeriod), &outBegIdx, &outNBElement, (*C.double)(unsafe.Pointer(&outReal[0])))
	return outReal[:outNBElement]
}
320196
func (o *Buffer) dec_ref_bool(p *Properties, base structPointer) error {
	u, err := p.valDec(o)
	if err != nil {
		return err
	}
	if len(o.bools) == 0 {
		o.bools = make([]bool, boolPoolSize)
	}
	o.bools[0] = u != 0
	*structPointer_RefBool(base, p.field) = o.bools[0]
	o.bools = o.bools[1:]
	return nil
}
136073
func (sis *SortedIntSet) incr(num int) {
	if sis.useTreeMap {
		val, ok := sis.dict[num]
		if !ok {
			sis.dict[num] = 1
		} else {
			sis.dict[num] = 1 + val
		}
		return
	}

	for i, v := range sis.values {
		if v == num {
			sis.counts[i]++
			return
		} else if num < v {
			// insert here
			sis.values = append(sis.values[:i], append([]int{num}, sis.values[i:]...)...)
			sis.counts = append(sis.counts[:i], append([]int{1}, sis.counts[i:]...)...)
			return
		}
	}

	// append
	sis.values = append(sis.values, num)
	sis.counts = append(sis.counts, 1)

	if len(sis.values) == TREE_MAP_CUTOVER {
		sis.useTreeMap = true
		for i, v := range sis.values {
			sis.dict[v] = sis.counts[i]
		}
	}
}