Rounds a signed list over the last element and removes it.
777045
def _roundSlist(slist):
    
    slist[-1] = 60 if slist[-1] >= 30 else 0
    for i in range(len(slist)-1, 1, -1):
        if slist[i] == 60:
            slist[i] = 0
            slist[i-1] += 1
    return slist[:-1]
932352
def discard(self, val):
        
        _maxes = self._maxes

        if not _maxes:
            return

        pos = bisect_left(_maxes, val)

        if pos == len(_maxes):
            return

        _lists = self._lists
        idx = bisect_left(_lists[pos], val)

        if _lists[pos][idx] == val:
            self._delete(pos, idx)
266842
def trim(self):
        ''''''
        now_time = time.time()

        while self._seq and self._seq[0].expire_time < now_time:
            item = self._seq.popleft()
            del self._map[item.key]

        if self._max_items:
            while self._seq and len(self._seq) > self._max_items:
                item = self._seq.popleft()
                del self._map[item.key]
933411
def strip_prefix_from_list(list, strip):
    
    for i in range(len(list)):
        list[i] = strip_prefix(list[i], strip)
798244
function remove(xs, x) {
  xs = xs || []
  var pos = xs.indexOf(x)
  if (pos != -1)  xs.splice(pos, 1)
  return xs }
1276820
function removeAt(items, index) {
  var copy = items.slice();
  copy.splice(index, 1);
  return copy;
}
372469
def _strip(self, tokens, criteria, prop, rev=False):
        """"""
        num = len(tokens)
        res = []
        for i, token in enumerate(reversed(tokens) if rev else tokens):
            if criteria(token) and num > i + 1:
                res.insert(0, tokens.pop()) if rev else res.append(tokens.pop(0))
            else:
                break
        if res:
            self[prop] = self._clean(' '.join(res))
        return tokens
672885
void clear(int list) {
		int last = getLast(list);
		while (last != nullNode()) {
			int n = last;
			last = getPrev(n);
			freeNode_(n);
		}
		m_lists.setField(list, 0, -1);
		m_lists.setField(list, 1, -1);
		setListSize_(list, 0);
	}
487399
function removeSubKeyFromList(list, sub, key, value) {
    for (var i = list.length - 1; i >= 0; i--) {
        if (a4p.isDefined(list[i][sub]) && (list[i][sub][key] == value)) {
            return list.splice(i, 1); // remove from array
        }
    }
    return false;
}
902363
private static void trimPadding(List<Element> elements)
    {
        for (ListIterator<Element> it = elements.listIterator(elements.size()); it.hasPrevious();) {
            Element element = it.previous();

            if (element.compareTo(null) == 0) {
                it.remove();
            } else {
                break;
            }
        }
    }
328790
public static int[] removeAt (int[] list, int index)
    {
        // this will NPE if the bastards passed a null list, which is how
        // we'll let them know not to do that
        int nlength = list.length-1;

        // create a new array minus the removed element
        int[] nlist = new int[nlength];
        System.arraycopy(list, 0, nlist, 0, index);
        System.arraycopy(list, index+1, nlist, index, nlength-index);

        return nlist;
    }
869009
private void cleanupLists(PrefixKey key) {
    // Remove expired list entries. Keep track of the last list removed.
    NavigableMap<PrefixKey, CacheValue<Object>> head = prefixMap.headMap(key, true).descendingMap();
    Iterator<Entry<PrefixKey, CacheValue<Object>>> headItr = head.entrySet().iterator();
    Entry<PrefixKey, CacheValue<Object>> last = null;

    while (headItr.hasNext()) {
      Entry<PrefixKey, CacheValue<Object>> entry = headItr.next();
      if (isExpired(entry.getValue()) && key.isParent(entry.getKey())) {
        last = entry;
        headItr.remove();
      }
    }

    // If a list was removed, check its contained items for expiration.
    if (last != null) {
      SortedMap<PrefixKey, CacheValue<GoogleCloudStorageItemInfo>> prefix =
          getPrefixSubMap(itemMap, last.getKey());
      prefix.entrySet().removeIf(entry -> isExpired(entry.getValue()));
    }
  }
832874
def remove(self, toRemove):
        '''
            
        '''
        list.remove(self, toRemove)
        self.uids.remove(toRemove.uid)
285591
def remove(self, element):
        """"""
        try:
            index = self.index(element)
        except ValueError:
            raise ValueError("list.remove(x): x not in list")
        else:
            self._notify_remove_at(index)
            super(ObservableList, self).pop(index)
934911
def discard(self, value):
        
        _set = self._set
        if value in _set:
            _set.remove(value)
            self._list.discard(value)
946622
def remove(self, uids: Iterable[int]) -> None:
        
        for uid in uids:
            self._recent.discard(uid)
            self._flags.pop(uid, None)
836899
private E unlinkLast(Node<E> l) {
        // assert l == last && l != null;
        final E element = l.item;
        final Node<E> prev = l.prev;
        l.item = null;
        l.prev = null; // help GC
        last = prev;
        if (prev == null)
            first = null;
        else
            prev.next = null;
        size--;
        modCount++;
        return element;
    }