Performs a pop and coerces to an int.
483754
def pop_int(self, key: str, default: Any = DEFAULT) -> int:
        
        value = self.pop(key, default)
        if value is None:
            return None
        else:
            return int(value)
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)
102719
def pop(self, *args):
        
        if len(args) < 3:
            return self._store.pop(*args)
        else:
            raise TypeError("pop expected at most 2 arguments, got {}".format(len(args)))
1223677
def spop(self, key, count=None, *, encoding=_NOTSET):
        """"""
        args = [key]
        if count is not None:
            args.append(count)
        return self.execute(b'SPOP', *args, encoding=encoding)
354225
public E pop() {
    E obj;
    int len = size();
    obj = peek();
    remove(len - 1);
    return obj;
  }
3972
@SuppressWarnings("unchecked")
	public <T> T rpoplpush(Object srcKey, Object dstKey) {
		Jedis jedis = getJedis();
		try {
			return (T)valueFromBytes(jedis.rpoplpush(keyToBytes(srcKey), keyToBytes(dstKey)));
		}
		finally {close(jedis);}
	}
418123
function () {
            var t = this.dpop() | 0;
            var n = this.dpop() | 0;
            var ddd = Long.fromInt(n);
            ddd = ddd.mul(Long.fromInt(t));
            this.dpush(ddd.low);
            this.dpush(ddd.high);
        }
645970
def coerce(cls, arg):
        """"""
        try:
            return cls(arg).value
        except (ValueError, TypeError):
            raise InvalidParameterDatatype("%s coerce error" % (cls.__name__,))
429730
public final boolean pop() throws XMLStreamException
    {
        if (mCurrElement == null) {
            throw new IllegalStateException("Popping from empty stack");
        }
        --mDepth;

        Element child = mCurrElement;
        Element parent = child.mParent;
        mCurrElement = parent;

        // Let's do simple recycling of Element instances...
        child.relink(mFreeElement);
        mFreeElement = child;
            
        // Need to purge namespaces?
        int nsCount = mNamespaces.size() - child.mNsOffset;
        if (nsCount > 0) { // 2 entries for each NS mapping:
            mLastNsContext = null; // let's invalidate ns ctxt too, if we had one
            mNamespaces.removeLast(nsCount);
        }
        return (parent != null);
    }
1321388
def rpop(self, key, *, encoding=_NOTSET):
        """"""
        return self.execute(b'RPOP', key, encoding=encoding)
1324449
private void pop( char c ) {
      if( this.top <= 0 || this.stack[this.top - 1] != c ){
         throw new JSONException( "Nesting error." );
      }
      this.top -= 1;
      this.mode = this.top == 0 ? 'd' : this.stack[this.top - 1];
   }
703969
function() {
	var id = this.uuid()
		, fx = fxObj[id]

	if (!fx) { return false }

	delete fxObj[id]

	this.fire('anim:pop', fx)
	
	return this.anim.apply(this, fx.from)
}
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
259364
public static int pop(long x) {
  /* Hacker's Delight 32 bit pop function:
   * http://www.hackersdelight.org/HDcode/newCode/pop_arrayHS.cc
   *
  int pop(unsigned x) {
     x = x - ((x >> 1) & 0x55555555);
     x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
     x = (x + (x >> 4)) & 0x0F0F0F0F;
     x = x + (x >> 8);
     x = x + (x >> 16);
     return x & 0x0000003F;
    }
  ***/

    // 64 bit java version of the C function from above
    x = x - ((x >>> 1) & 0x5555555555555555L);
    x = (x & 0x3333333333333333L) + ((x >>>2 ) & 0x3333333333333333L);
    x = (x + (x >>> 4)) & 0x0F0F0F0F0F0F0F0FL;
    x = x + (x >>> 8);
    x = x + (x >>> 16);
    x = x + (x >>> 32);
    return ((int)x) & 0x7F;
  }
1249211
def coerce_value(cls, v):
        """"""
        if isinstance(v, cls.itemtype):
            return v
        else:
            try:
                return cls.coerceitem(v)
            except Exception as e:
                raise exc.CollectionItemCoerceError(
                    itemtype=cls.itemtype,
                    colltype=cls,
                    passed=v,
                    exc=e,
                )
812495
def inten(function):
    ""
    def wrapper(*args, **kwargs):
        return coerce_to_int(function(*args, **kwargs))
    return wrapper
1166163
@Override
    public N pop() {
        try {
            return stack[(--stackTop)&mask];
        } finally {
            // remove the reference to the element in the
            // stack to prevent hanging references from living forever
            stack[(stackTop&mask)] = null;
        }
    }