Pop the last entry from the stack file.
 @return [String or nil] Popped entry or nil if stack is already empty.
500782
def pop
      begin
        return nil if @f.size == 0

        @f.seek(-@entry_bytes, IO::SEEK_END)
        bytes = @f.read(@entry_bytes)
        @f.truncate(@f.size - @entry_bytes)
        @f.flush
      rescue => e
        PEROBS.log.fatal "Cannot pop from stack file #{@file_name}: " +
          e.message
      end

      bytes
    end
909137
def stack_pop(self):
        
        sp = self.regs.sp
        self.regs.sp = sp - self.arch.stack_change
        return self.memory.load(sp, self.arch.bytes, endness=self.arch.memory_endness)
1121837
@Override
    public final N pop() {

        int spin = 0;
        // now pop the stack
        for(;;) {
            final long writeLock = seqLock.tryWriteLock();
            if(writeLock > 0) {
                try {
                    final int stackTop = this.stackTop.get();
                    final int lastRef = stackTop-1;
                    if(stackTop>0) {
                        try {
                            // if we can modify the stack - i.e. nobody else is modifying
                            final N n = stack.get(lastRef);
                            stack.set(lastRef, null);
                            stackNotFullCondition.signal();
                            return n;
                        } finally {
                            this.stackTop.set(lastRef);
                        }
                    } else {
                        return null;
                    }
                } finally {
                    seqLock.unlock(writeLock);
                }
            }

            spin = Condition.progressiveYield(spin);

        }
    }
92928
def last(from: nil, to: nil, &block)
      retval = nil

      each_with_depth(from: from, to: nil) do |line, depth, index|
        retval = line if block.call(line, depth, index)
      end

      retval
    end
522024
def pop(non_block = false)
      buffer_from_socket_nonblock
      message = message_from_buffer_nonblock
      unless non_block
        # we can block
        while message.nil?
          r, _d, _d = IO.select([@socket])
          if r && r[0] == @socket
            buffer_from_socket_nonblock
            message = message_from_buffer_nonblock
          end
        end
      end
      message
    end
27399
public E popWithLimit(int minSize) {
        StackNode<E> oldTop, newTop;

        while (true) {
            oldTop = top.get();
            if (oldTop == null)
                return null;

            if (oldTop.index + 1 <= minSize)
                return null;

            newTop = oldTop.next;
            if (top.compareAndSet(oldTop, newTop))
                break;
        }

        return oldTop.data;
    }
1011764
def Pop(self, index=0):
    """"""
    if index < 0:
      index += len(self)

    if index == 0:
      result = self.__class__()
      result.SetRawData(self.GetRawData())

      self.SetRawData(self.nested_path.GetRawData())

    else:
      # Get the raw protobufs for the previous member.
      previous = self[index - 1]

      result = previous.nested_path

      # Manipulate the previous members protobuf to patch the next component in.
      previous.nested_path = result.nested_path

    result.nested_path = None

    return result
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
626523
def pop_all(self):
        
        ret = ExitStack()
        ret._context_stack.append(self._context_stack.pop())
        self._context_stack.append([])
1297026
public T pop()
    {
        T val = beginChunk.values[beginPos];
        beginChunk.values[beginPos] = null;
        beginPos++;
        if (beginPos == size) {
            beginChunk = beginChunk.next;
            beginChunk.prev = null;
            beginPos = 0;
        }
        return val;
    }
482063
def _last_stack_str():
    """"""
    stack = extract_stack()
    for s in stack[::-1]:
        if op.join('vispy', 'gloo', 'buffer.py') not in __file__:
            break
    return format_list([s])[0]
604058
def pop_queue
      until @queue.empty?
        nextdir = File.join(repo_dir, @queue.pop)
        if File.directory?(nextdir)
          @next = find_next(Dir.new(nextdir))
          return @next
        else
          @logger.warn("When processing in #{@repository}, no such path #{nextdir}")
        end
      end
      @next = nil
    end
142210
def pop(self):
        
        if not self.empty():
            val = self.stack[-1]
            del self.stack[-1]
            return val
268884
def pop
      m = nil
      @lock.synchronize do
        [:PRIORITY, :NEW, :NORMAL, :WHOCARES].each do |k|
          unless(@queues[k].empty?)
            q = @queues[k].shift
            unless(q.empty?)
              m = q.shift
              add_queue(k, q) unless(q.empty?)
              break
            end
          end
        end
      end
      unless(m)
        if(@raise)
          raise EmptyQueue.new('Queue is currently empty')
        else
          @lock.wait_while{ empty? }
          m = pop
        end
      end
      m
    end
1006113
def pop
      alarm = (Time.now + @wait_timeout)
      clnt = nil
      dirty = false
      while !@shutdown
        raise_alarm if (Time.now > alarm)
        @mutex.synchronize do
          begin
            if clnt = @_pool.pop
              dirty = true
            else
              clnt = _fetch_new(&@client_block)
            end
          ensure
            if clnt
              _checkout(clnt)
              @cond.signal
            else
              @reaper.wakeup if @reaper && _dead_clients?
              @cond.wait(@mutex,@wait_timeout)
            end
          end
        end
        break if clnt
      end
      clean_client(clnt) if dirty && clnt
      clnt
    end
1114343
async def pop(self, full):
        '''
        
        '''
        node = self.nodes.get(full)
        if node is None:
            return

        valu = await self._popHiveNode(node)

        return valu
351350
def pop(self):
        
        if len(self.stack):      
            popped = self.stack.pop()
            #log.debug('pop: (%s)\n%s', Repr(popped), Repr(self.stack))
            return popped
        else:
            #log.debug('stack empty, not-popped')
            pass
        return None