pop the item with the string(hex) value for the number specified by +count+ from the stack.
429391
def pop_string(count = 1)
      s = stack.pop(count).map do |s|
        case s
        when Numeric
          Script.encode_number(s)
        else
          s
        end
      end
      count == 1 ? s.first : s
    end
1300560
def stack_pop(self, key):
        
        task = Task.current_task()
        try:
            context = task._context_stack
        except AttributeError:
            raise KeyError('pop from empty stack') from None
        value = context[key]
        stack_value = value.pop()
        if not value:
            context.pop(key)
        return stack_value
866017
def count(self, item):
        """"""
        # pylint: disable=arguments-differ
        key, value = item
        return 1 if key in self._dict and self._dict[key] == value else 0
838755
def pop(h):
    """"""
    n = h.size() - 1
    h.swap(0, n)
    down(h, 0, n)
    return h.pop()
423522
function pop(stack, metaStack) {
  var obj = stack.pop();

  if (metaStack.length) {
    var lastMetaElement = metaStack[metaStack.length - 1];
    if (obj === lastMetaElement.element) {
      // popping a meta-element, e.g. an object whose value is another object
      metaStack.pop();
      lastMetaElement = metaStack[metaStack.length - 1];
    }
    var element = lastMetaElement.element;
    var lastElementIndex = lastMetaElement.index;
    if (Array.isArray(element)) {
      element.push(obj);
    } else if (lastElementIndex === stack.length - 2) { // obj with key+value
      var key = stack.pop();
      element[key] = obj;
    } else {
      stack.push(obj); // obj with key only
    }
  }
}
977826
def pop(queue, quantity=1, is_runner=False):
    '''
    
    '''
    cmd = 'SELECT name FROM {0}'.format(queue)
    if quantity != 'all':
        try:
            quantity = int(quantity)
        except ValueError as exc:
            error_txt = ('Quantity must be an integer or "all".\n'
                         'Error: "{0}".'.format(exc))
            raise SaltInvocationError(error_txt)
        cmd = ''.join([cmd, ' LIMIT {0}'.format(quantity)])
    log.debug('SQL Query: %s', cmd)
    con = _conn(queue)
    items = []
    with con:
        cur = con.cursor()
        result = cur.execute(cmd).fetchall()
        if result:
            items = [item[0] for item in result]
            itemlist = '","'.join(items)
            _quote_escape(itemlist)
            del_cmd = '''DELETE FROM {0} WHERE name IN ("{1}")'''.format(
                queue, itemlist)

            log.debug('SQL Query: %s', del_cmd)

            cur.execute(del_cmd)
        con.commit()
    if is_runner:
        items = [salt.utils.json.loads(item[0].replace("'", '"')) for item in result]
    log.info(items)
    return items
703465
def valuePop(ctxt):
    
    if ctxt is None: ctxt__o = None
    else: ctxt__o = ctxt._o
    ret = libxml2mod.valuePop(ctxt__o)
    return ret
1352566
def pop(self):
        

        if self.stack:
            val = self.stack[0]
            self.stack = self.stack[1:]
            return val
        else:
            raise StackError('Stack empty')
146952
def pop(self):
        """"""

        if self._count == 0:
            raise StreamEmptyError("Pop called on virtual stream walker without any data", selector=self.selector)

        self._count = self._count - 1
        return self.reading
599163
def pop(self, key=-1):
    """"""
    value = self._values[key]
    self.__delitem__(key)
    return value
120157
def pop(self, index=None):
        
        if index is None:
            return self._loads(self._client.rpop(self.key_prefix))
        elif index == 0:
            return self._loads(self._client.lpop(self.key_prefix))
        else:
            _uuid = gen_rand_str(16, 24)
            r = self[index]
            self[index] = _uuid
            self.remove(_uuid)
            return r
142210
def pop(self):
        
        if not self.empty():
            val = self.stack[-1]
            del self.stack[-1]
            return val
452878
function _string_pop(&$string, $index = 1)
    {
        $substr = substr($string, -$index);
        $string = substr($string, 0, -$index);
        return $substr;
    }
1268705
def popleft(self):
        """"""
        self._mq.send("^", True, type=1)
        message = self._wait_receive_msg()
        reply = int(message[0].decode('utf-8'))
        #print(reply)
        if reply == -1:
            raise IndexError("pop from empty list")
        return reply
18443
private void popLastItem() {
        KeyValue<K,V> lastKV = items.last();
        items.remove(lastKV);
        index.remove(lastKV.key);
    }
1024980
def pop(self):
        """"""
        try:
            return self.data_stack.pop()
        except errors.MachineError as e:
            raise errors.MachineError("%s: At index %d in code: %s" %
                    (e, self.instruction_pointer, self.code_string))
12111
def pop_arguments(instr, stack):
    
    needed = instr.stack_effect
    if needed >= 0:
        raise DecompilationError(
            "%s is does not have a negative stack effect" % instr
        )

    for popcount, to_pop in enumerate(reversed(stack), start=1):
        needed += to_pop.stack_effect
        if not needed:
            break
    else:
        raise DecompilationError(
            "Reached end of stack without finding inputs to %s" % instr,
        )

    popped = stack[-popcount:]
    stack[:] = stack[:-popcount]

    return popped