Pop value from top of stack

@return int of value
771006
public final int pop() {
		if (stackPointer == 0) {
			return null_value;
		}
		final int element = stack[--stackPointer];
		stack[stackPointer] = null_value;
		return element;
	}
1056186
public Object pop()
  {
    Object val = m_map[--m_firstFree];
    m_map[m_firstFree] = null;
    
    return val;
  }
892416
public function pop()
    {
        $value = $this->stack[$this->current];

        unset($this->stack[$this->current]);

        --$this->current;

        if ($this->current < 0) {
            $this->reset();
        }

        return $value;
    }
1305431
public static InsnList pop() {
        InsnList ret = new InsnList();
        ret.add(new InsnNode(Opcodes.POP));

        return ret;
    }
64427
public function pop()
    {
        if ($this->isEmpty()) {
            throw new UnderflowException();
        }

        // Last leaf of the heap to become the new root.
        $leaf = array_pop($this->heap);

        if (empty($this->heap)) {
            return $leaf->value;
        }

        // Cache the current root value to return before replacing with next.
        $value = $this->getRoot()->value;

        // Replace the root, then sift down.
        $this->setRoot($leaf);
        $this->checkCapacity();

        return $value;
    }
181127
def pop_int(count = 1)
      i = stack.pop(count).map{ |s| cast_to_int(s) }
      count == 1 ? i.first : i
    end
450695
public final Node pop()
  {

    m_firstFree--;

    Node n = m_map[m_firstFree];

    m_map[m_firstFree] = null;

    return n;
  }
992857
public function pop()
    {
        if (0 === count($this->array)) {
            return null;
        }

        // get the last hash of array
        end($this->array);
        $hash = key($this->array);

        // temporarily hold the element at that spot
        $element = $this->array[$hash];

        // forget it in our map and return our temporary
        $this->forget($this->hash_to_key($hash));

        return $element;
    }
163993
public function popField()
    {
        if ($this->getCount() > 0) {
            $fields = $this->removeFieldAtIndex($this->getCount() - 1);
            return $fields[0];
        }

        throw new \OutOfRangeException("Can't call popField when the field count is 0");
    }
1187494
public boolean popTable() {
        if (currentLevel > 0) {
            //Remove all the variable having a level equals to currentLevel
            for (Iterator<Map.Entry<String, Integer>> ite = level.entrySet().iterator(); ite.hasNext(); ) {
                Map.Entry<String, Integer> e = ite.next();
                if (e.getValue() == currentLevel) {
                    ite.remove();
                    type.remove(e.getKey());
                }
            }
            currentLevel--;
            return true;
        }
        return false;
    }
873551
def pop_max(self):
        

        if self.root is NULL:
            raise KeyError("pop from an empty blackjack")

        self.root, value = self.root.delete_max()
        self._len -= 1
        return value
939970
def pop(self, index=-1) -> Union[int, Expression]:
        

        try:
            return super(MachineStack, self).pop(index)
        except IndexError:
            raise StackUnderflowException("Trying to pop from an empty stack")
1304273
public function peek()
    {
        $c = count($this->stack);
        if ($c == 0) {
            throw new \UnexpectedValueException("The stack is empty. You should probably peek() before the last end() call.");
        }
        $ret = $this->stack[$c -1];
        return $ret;
    }
190365
public function pop_front()
    {
        if ($this->count() <= 0) {
            throw new \OutOfBoundsException();
        }

        $item = $this->list[0];

        $this->removeFirst();

        return $item;
    }
1051993
public function pop() {
        if (null === $this->stack) return null;
        if ($this->isEmpty()) return null;

        $this->size--;
        $value = $this->stack[$this->size];
        return $value;
    }
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
364894
public final T allocate()
  {
    AtomicInteger topRef = _top;
    
    while (true) {
      final int top = topRef.get();

      if (top <= 0) {
        return null;
      }
      else if (topRef.compareAndSet(top, top - 1)) {
        T value = _freeStack.getAndSet(top - 1, null);
        
        if (value != null) {
          return value;
        }
      }
    }
  }