Returns the amount of previous remaining list nodes.
978908
public int getPreviousRemaining() {
        int remaining = mPrevRemaining;
        if (remaining < 0) {
            mPrevRemaining = remaining =
                ((mPrev == null) ? 0 : (mPrev.getPreviousRemaining() + 1));
        }
        return remaining;
    }
853652
public static <T> T getLast(List<T> list)
    {
        if (list == null)
        {
            return null;
        }
        if (list instanceof RandomAccess)
        {
            return RandomAccessListIterate.getLast(list);
        }
        ListIterator<T> iterator = list.listIterator(list.size());
        if (iterator.hasPrevious())
        {
            return iterator.previous();
        }
        return null;
    }
1236919
int deleteList(int list) {
		clear(list);
		int prevList = m_lists.getField(list, 2);
		int nextList = m_lists.getField(list, 3);
		if (prevList != nullNode())
			setNextList_(prevList, nextList);
		else
			m_list_of_lists = nextList;

		if (nextList != nullNode())
			setPrevList_(nextList, prevList);

		freeList_(list);
		return nextList;
	}
609320
def get_last_lineno(node):
    """"""
    max_lineno = 0

    if hasattr(node, "lineno"):
        max_lineno = node.lineno

    for _, field in ast.iter_fields(node):
        if isinstance(field, list):
            for value in field:
                if isinstance(value, ast.AST):
                    max_lineno = max(max_lineno, get_last_lineno(value))

        elif isinstance(field, ast.AST):
            max_lineno = max(max_lineno, get_last_lineno(field))

    return max_lineno
1131245
private int remainingVars() {
        int res = maxvar();
        res -= this.stats.varsFixed;
        res -= this.stats.varsEquivalent;
        res -= this.stats.varsEliminated;
        return res;
    }
1088420
def get_tail(self):
        
        node = self.head
        last_node = self.head

        while node is not None:
            last_node = node
            node = node.next_node

        return last_node
1254644
static function fetchListCount()
    {
        $sql = "SELECT count( node_id ) as count FROM ezcontentobject_tree";
        $db = eZDB::instance();
        $rows = $db->arrayQuery( $sql );
        return $rows[0]['count'];
    }
379853
async def prev(self, count=None):
        
        if self._prev_uri is None:
            return self[:0]  # An empty slice of `self`.
        else:
            return self._fetch(self._prev_uri, count)
444792
public function previousAll()
    {
        if (!$this->nodes) {
            throw new \InvalidArgumentException('The current node list is empty.');
        }

        return $this->createSubCrawler($this->sibling($this->getNode(0), 'previousSibling'));
    }
790016
public Node previousSibling() {

		if (currentNode == null)
			return null;

		Node node = getPreviousSibling(currentNode);
		if (node != null)
			currentNode = node;

		return node;
	}
1143481
def count(self, elem):
        
        return self._left_list.count(elem) + self._right_list.count(elem)
218152
def fetch_remaining_instances(self):
        """"""
        if self.remaining_items:
            self.remaining_items = ContentItem.objects.get_real_instances(self.remaining_items)
1305467
function(nodeList){
			var last = nodeList[nodeList.length - 1];
			// If the last node in the list is not an HTMLElement
			// it is a nodeList so call `last` again.
			if(last.nodeType) {
				return last;
			} else {
				return nodeLists.last(last);
			}
		}
1226593
private int countOfMode(boolean data) {
        restartFromHead: for (;;) {
            int count = 0;
            for (Node p = head; p != null;) {
                if (!p.isMatched()) {
                    if (p.isData != data)
                        return 0;
                    if (++count == Integer.MAX_VALUE)
                        break;  // @see Collection.size()
                }
                if (UNLINKED == (p = p.next))
                    continue restartFromHead;
            }
            return count;
        }
    }
546894
private int getNumRnaNodes(Collection<KamNode> nodes) {
        int count = 0;
        for (KamNode node : nodes) {
            if (node.getFunctionType() == FunctionEnum.RNA_ABUNDANCE) {
                count++;
            }
        }
        return count;
    }
990713
def last_n_results(self, n):
        
        return list(
            itertools.islice(
                self.results, len(self.results) - n, len(self.results)
            )
        )
978598
public int getCurrentNode()
  {

    if (!m_cacheNodes)
      throw new RuntimeException(
        "This NodeSetDTM can not do indexing or counting functions!");

    int saved = m_next;
    // because nextNode always increments
    // But watch out for copy29, where the root iterator didn't
    // have nextNode called on it.
    int current = (m_next > 0) ? m_next-1 : m_next; 
    int n = (current < m_firstFree) ? elementAt(current) : DTM.NULL;
    m_next = saved; // HACK: I think this is a bit of a hack.  -sb
    return n;
  }