Pop a value at *index* from the :class:`TS`. Return ``None`` if
index is not out of bound.
776768
def ipop(self, index):
        ''''''
        backend = self.backend
        res = backend.structure(self).ipop(index)
        return backend.execute(res,
                               lambda r: self._load_get_data(r, index, None))
337132
def pop(self, key, default=MISSING):
        
        try:
            val = self[key]
        except KeyError:
            if default is MISSING:
                raise
            val = default
        else:
            del self[key]
        return val
606287
def pop(self, name):
        """"""
        name = mkey(name)
        temp = mkey((name, "__poptmp__"))
        self.rename(name, temp)
        value = self[temp]
        del(self[temp])
        return value
1130859
def try_pop(d, key, default):
    
    value = d.get(key, default)
    if key in d:
        d.pop(key)
    return value
57151
def pop(self, key, default=None):
        ""
        if not isinstance(key, tuple): key = (key,)
        return self.data.pop(key, default)
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
1114343
async def pop(self, full):
        '''
        
        '''
        node = self.nodes.get(full)
        if node is None:
            return

        valu = await self._popHiveNode(node)

        return valu
282792
def pop(self, amount=1) -> Union[BitVec, List[BitVec]]:
        
        if amount > len(self.stack):
            raise StackUnderflowException
        values = self.stack[-amount:][::-1]
        del self.stack[-amount:]

        return values[0] if amount == 1 else values
84171
def pop(self):
        
        stack = getattr(self._local, "stack", None)
        if stack is None:
            return None
        elif len(stack) == 1:
            release_local(self._local)
            return stack[-1]
        else:
            return stack.pop()
493072
def pop(self, key, default=None):
        
        if key not in self:
            if default is not None:
                return default
            raise KeyError(key)
        for map in [self._pb.IntMap, self._pb.FloatMap, self._pb.StringMap,
                    self._pb.BoolMap]:
            if key in map.keys():
                return map.pop(key)
824424
def pop(self, arg=None):
        """"""
        self._stable = False
        if arg is None:
            arg = len(self.childs) - 1
        if isinstance(arg, int):
            try:
                result = self.childs.pop(arg)
            except IndexError:
                raise DOMModByIndexError(self, "Given index invalid.")
            if isinstance(result, DOMElement):
                result.parent = None
        else:
            result = []
            if isinstance(arg, str):
                arg = [arg]
            for x in arg:
                try:
                    result.append(getattr(self, x))
                except AttributeError:
                    raise DOMModByKeyError(
                        self, "Given search key invalid. No child found."
                    )
            if result:
                for x in result:
                    self.childs.remove(x)
                    if isinstance(x, DOMElement):
                        x.parent = False
        return result
703465
def valuePop(ctxt):
    
    if ctxt is None: ctxt__o = None
    else: ctxt__o = ctxt._o
    ret = libxml2mod.valuePop(ctxt__o)
    return ret
493402
def _pop(self, key, default=None):
        
        value = default
        if key in self:
            value = self[key]
            del self[key]
        return value
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
140560
def pop_front(self):
        ''''''
        backend = self.backend
        return backend.execute(backend.structure(self).pop_front(),
                               self.value_pickler.loads)
52709
def pop(self, index=-1):
		""""""
		value = self._list.pop(index)
		del self._dict[value]
		return value
800747
function(arr, value) {
        var inx = arr.indexOf(value);
        var endIndex = arr.length - 1;
        if (inx !== endIndex) {
            var temp = arr[endIndex];
            arr[endIndex] = arr[inx];
            arr[inx] = temp;
        }
        arr.pop();
    }