Pop the frame at the top of the stack.
        @return: The popped frame, else None.
        @rtype: L{Frame}
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
1352472
public synchronized E pop() {
        E       obj;
        int     len = size();

        obj = peek();
        removeElementAt(len - 1);

        return obj;
    }
296393
def getTopLeft(self):
        
        return (float(self.get_x()), float(self.get_y())+ float(self.get_height()))
1366355
private LazyNode pop(){
		LazyNode value=stackTop;
		stackPointer--;
		if(stackPointer>0){
			stackTop=stack[stackPointer-1];
		}
		return value;
	}
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;
        }
    }
938976
def pop_frame(self):
        
        try:
            offset, return_pos = self._frames.pop()
        except IndexError:
            raise IndexError('no frames to pop')
        self._total_offset -= offset

        self.seek(return_pos)
1114343
async def pop(self, full):
        '''
        
        '''
        node = self.nodes.get(full)
        if node is None:
            return

        valu = await self._popHiveNode(node)

        return valu
1152152
def pop_viewport(self):
        
        vp = self._vp_stack.pop()
        # Activate latest
        if len(self._vp_stack) > 0:
            self.context.set_viewport(*self._vp_stack[-1])
        else:
            self.context.set_viewport(0, 0, *self.physical_size)
        
        self._update_transforms()
        return vp
440404
def root_frame(self, trim_stem=True):
        ''' 
        
        '''
        root_frame = None

        frame_stack = []

        for frame_tuple in self.frame_records:
            identifier_stack = frame_tuple[0]
            time = frame_tuple[1]

            # now we must create a stack of frame objects and assign this time to the leaf
            for stack_depth, frame_identifier in enumerate(identifier_stack):
                if stack_depth < len(frame_stack):
                    if frame_identifier != frame_stack[stack_depth].identifier:
                        # trim any frames after and including this one
                        del frame_stack[stack_depth:]

                if stack_depth >= len(frame_stack):
                    frame = Frame(frame_identifier)
                    frame_stack.append(frame)
                    
                    if stack_depth == 0:
                        # There should only be one root frame, as far as I know
                        assert root_frame is None, ASSERTION_MESSAGE
                        root_frame = frame
                    else:
                        parent = frame_stack[stack_depth-1]
                        parent.add_child(frame)

            # trim any extra frames
            del frame_stack[stack_depth+1:]  # pylint: disable=W0631

            # assign the time to the final frame
            frame_stack[-1].add_child(SelfTimeFrame(self_time=time))
        
        if root_frame is None:
            return None
        
        if trim_stem:
            root_frame = self._trim_stem(root_frame)
        
        return root_frame
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)
1352566
def pop(self):
        

        if self.stack:
            val = self.stack[0]
            self.stack = self.stack[1:]
            return val
        else:
            raise StackError('Stack empty')
165529
def pop(self, i=None):
        """"""
        if i is None:
            i = len(self) - 1
        val = self[i]
        del(self[i])
        return val
252545
public T pop() {
		final int max = stack.size() - 1;
		if (max < 0) {
			throw new NoSuchElementException();
		}
		return stack.remove(max);
	}
162127
public Frame  popXAry()  {
    Frame fr = popAry();
    for( Vec vec : fr.vecs() ) {
      popVec(vec);
      if ( vec.masterVec() != null ) popVec(vec.masterVec());
    }
    return fr;
  }
1144435
def clear(self):
        '''
        
        '''
        l = len(self)
        ret = self._clear()
        if self.parent is not None:
            pr = self.parent.notifyPop(self, l)
            ret[0].extend(pr[0])
            ret[1].extend(pr[1])
        return ret
399881
def topWindow():
    
    import_qt(globals())
    
    window = QtGui.QApplication.instance().activeWindow()
    if not window:
        return None
    
    parent = window.parent()
    
    while parent:
        window = parent
        parent = window.parent()
        
    return window
184909
def pop(self: BoardT) -> Move:
        
        move = self.move_stack.pop()
        self._stack.pop().restore(self)
        return move