// pushBin pushes the value v to the binary stack.
775467
func (c *Compiler) pushBin(v interface{}) {
	if c.debug {
		fmt.Printf("%d: %v\n", len(c.binary), v)
	}
	c.binary = append(c.binary, v)
}
1334480
func (l *ItemList) PushBack(v Item) *ItemElement {
	l.lazyInit()
	return l.insertValue(v, l.root.prev)
}
683871
func (levelDB *LevelDB) PushKeyVal(key string, val string) bool {
	err := levelDB.GolDB.Put([]byte(key), []byte(val), nil)
	if err != nil {
		golerror.Boohoo("Key "+key+" insertion failed. It's value was "+val, false)
		return false
	}
	return true
}
760864
func (stack *CoordStack) Push(data []float64, idx int) []float64 {
	c := data[idx : idx+stack.stride]
	stack.Data = append(stack.Data, c...)
	return c
}
500423
func (p *parser) pushOptions() {
	p.optionsStack = append(p.optionsStack, p.options)
}
877519
func (s *Stack) Push(elem ...interface{}) {
	if elem == nil || len(elem) == 0 {
		return
	}

	// ensures enough pages are ready to be
	// filled in and then fills them from
	// the provided elem array
	if s.size+len(elem) > s.capacity {
		newPages := len(elem) / s.pageSize
		if len(elem)%s.pageSize != 0 {
			newPages++
		}

		// appending new empty pages
		for newPages > 0 {
			page := make([]interface{}, s.pageSize)
			s.pages = append(s.pages, page)
			s.capacity += len(page)
			newPages--
		}
	}

	// now that we have enough pages
	// we can start copying the elements
	// into the stack
	s.size += len(elem)
	for len(elem) > 0 {
		available := len(s.currentPage) - s.offset
		min := len(elem)
		if available < min {
			min = available
		}
		copy(s.currentPage[s.offset:], elem[:min])
		elem = elem[min:]
		s.offset += min
		if len(elem) > 0 {
			// page fully filled; move to the next one
			s.currentPage = s.pages[s.currentPageIndex+1]
			s.currentPageIndex++
			s.offset = 0
		}
	}
}
116477
func pushBigInt(n *big.Int, ctx *duktape.Context) {
	ctx.GetGlobalString("bigInt")
	ctx.PushString(n.String())
	ctx.Call(1)
}
152359
func NewBin(name string, value interface{}) *Bin {
	return &Bin{
		Name:  name,
		Value: NewValue(value),
	}
}
409657
func (m *Accumulator) Pushf(fmtstr string, args ...interface{}) {
	*m = append(*m, fmt.Errorf(fmtstr, args...))
}
20535
func (l *PacketList) PushBack(v Packet) *PacketElement {
	l.lazyInit()
	return l.insertValue(v, l.root.prev)
}
456666
func (x *Vector) PushFixed(y float64) error {
	lenx := len(*x)
	if lenx <= cap(*x) {
		slicex := (*x)[1:]
		z := make([]float64, lenx, lenx)
		copy(z, slicex)
		z[lenx-1] = y
		*x = z
		return nil
	} else {
		return fmt.Errorf("GoVector length greater than capacity!? len: %d cap: %d\n%#v", len(*x), cap(*x), x)
	}
}
1015216
func (g *Noop) Push(ctx context.Context, origin, branch string) error {
	return nil
}
1200125
func (s *scopeStack) push() {
	s.scopes = append(s.scopes, make(map[string]Value))
}
406406
func (d *Decoder) pushEOF() {
	// Walk down stack to find Start.
	// It might not be the top, because there might be stkNs
	// entries above it.
	start := d.stk
	for start.kind != stkStart {
		start = start.next
	}
	// The stkNs entries below a start are associated with that
	// element too; skip over them.
	for start.next != nil && start.next.kind == stkNs {
		start = start.next
	}
	s := d.free
	if s != nil {
		d.free = s.next
	} else {
		s = new(stack)
	}
	s.kind = stkEOF
	s.next = start.next
	start.next = s
}
1247436
func (dc *Context) Push() {
	x := *dc
	dc.stack = append(dc.stack, &x)
}
860008
func pushStack(fromSel *Selection, nodes []*html.Node) *Selection {
	result := &Selection{nodes, fromSel.document, fromSel}
	return result
}
1258888
func (st *Stack) PushBytes(bz []byte) {
	if len(bz) != 32 {
		panic("Invalid bytes size: expected 32")
	}
	st.Push(LeftPadWord256(bz))
}