Removes the node specified from the heap
@param i the valid heap node index to remove from the heap
@return the value that was stored in the heap node
165157
protected int removeHeapNode(int i)
    {
        int val = heap[i];
        int rightMost = --size;
        heap[i] = heap[rightMost];
        heap[rightMost] = 0;
        if(fastValueRemove == Mode.HASH)
        {
            valueIndexMap.remove(val);
            if(size != 0)
                valueIndexMap.put(heap[i], i);
        }
        else if(fastValueRemove == Mode.BOUNDED)
        {
            valueIndexStore[val] = -1;
        }
        heapDown(i);
        return val;
    }
434107
public void remove(int idx) {
        size--;
        System.arraycopy(data, idx + 1, data, idx, size - idx);
    }
1002518
public Object remove(int index) {

        //Check that the index is less than size because the getInternal
        //method is being called with index - 1 and its checks will therefore
        //not be useful in this case.
        if (index >= size()) {
            throw new IndexOutOfBoundsException("Index out of bounds: "
                                                + index + " >= " + size());
        }

        //Get the node that is previous to the node being removed
        Node previousToRemove;

        if (index == 0) {
            previousToRemove = first;
        } else {
            previousToRemove = getInternal(index - 1);
        }

        //previousToRemove.next will never be null because of the check above
        //that index < size.
        Node toRemove = previousToRemove.next;

        previousToRemove.next = toRemove.next;

        elementCount--;

        //If they removed at the last valid index, then a the last element
        //was removed, therfore update the last pointer
        if (last == toRemove) {
            last = previousToRemove;
        }

        return toRemove.data;
    }
153949
public Object remove(int index) {
    Object o = opt(index);
    this.myArrayList.remove(index);
    return o;
  }
294256
public void remove( int idx ) 
    {
        if ( idx < 0 || idx > size )
            throw new IndexOutOfBoundsException();
        int numMove = size - idx - 1;
        if ( numMove > 0 )
            System.arraycopy(items, idx + 1, items, idx, numMove);
        size--;
    }
556662
public synchronized Node removeNode(final String jvmRoute) {
        final Node node = nodes.get(jvmRoute);
        if (node != null) {
            removeNode(node);
        }
        return node;
    }
1259511
void quickRemove(int i) {
        assert i <= size;

        queue[i] = queue[size];
        queue[size--] = null;  // Drop extra ref to prevent memory leak
    }
387331
private void heapifyUp(int i)
    {
        int iP = parent(i);
        while(i != 0 && cmp(i, iP) < 0)//Should not be greater then our parent
        {
            swapHeapValues(iP, i);
            i = iP;
            iP = parent(i);
        }
    }
178164
@Nullable
  public final Node removeFirstChild() {
    Node child = first;
    if (child != null) {
      removeChild(child);
    }
    return child;
  }
304176
public void remove(int node) {
        if (node == NIL) {
            throw new IllegalArgumentException();
        }
        if (left(node) != NIL && right(node) != NIL) {
            // inner node
            final int next = next(node);
            assert next != NIL;
            swap(node, next);
        }
        assert left(node) == NIL || right(node) == NIL;

        final int parent = parent(node);
        int child = left(node);
        if (child == NIL) {
            child = right(node);
        }

        if (child == NIL) {
            // no children
            if (node == root) {
                assert size() == 1 : size();
                root = NIL;
            } else {
                if (node == left(parent)) {
                    left(parent, NIL);
                } else {
                    assert node == right(parent);
                    right(parent, NIL);
                }
            }
        } else {
            // one single child
            if (node == root) {
                assert size() == 2;
                root = child;
            } else if (node == left(parent)) {
                left(parent, child);
            } else {
                assert node == right(parent);
                right(parent, child);
            }
            parent(child, parent);
        }

        release(node);
        rebalance(parent);
    }
587124
public boolean remove(T element) {
		for (Iterator<Node<T>> it = nodes.iterator(); it.hasNext(); )
			if (ObjectUtil.equalsOrNull(it.next().element, element)) {
				it.remove();
				return true;
			}
		return false;
	}
1175622
public TransportCandidate getCandidate(int i) {
        TransportCandidate cand;

        synchronized (candidates) {
            cand = candidates.get(i);
        }
        return cand;
    }
908183
function(i) {
      
      var itemValue = this.items[i];
   
      this.ul.removeChild(this.ul.childNodes[i]);
      
      this.items[i] = null;
      this.items = inputEx.compactArray(this.items);
      
      return itemValue;
   }
172451
public Node removeChild(final String name) {
        final Node node = getSingle(name);
        if (node != null) {
            removeChild(node);
        }
        return node;
    }
742505
@SuppressWarnings("unchecked")
    public static <E> E get(Object list, int i) {
        if (list == null)
            throw new IndexOutOfBoundsException();

        if (list instanceof List)
            return (E) ((List<?>) list).get(i);

        if (i == 0)
            return (E) list;

        throw new IndexOutOfBoundsException();
    }
1056405
public String getValue(int i) {
        if (i < 0 || i >= values.size()) {
            return null;
        }
        return values.get(i);
    }
1334084
@Override
    public T remove(int index) {
        /* Cache the value at the indicated position; this also does the bounds
         * check.
         */
        T result = get(index);

        /* Use a naive shuffle-down algorithm to reposition elements after
         * the removed one.
         */
        for (int i = index + 1; i < size(); ++i)
            set(i - 1, get(i));

        /* Clobber the last element to play nicely with the garbage collector. */
        set(size() - 1, null);

        /* Decrement our size. */
        --mSize;

        /* If we are now at 1/8 total capacity, shrink the structure. */
        if (size() * 8 <= mArrays.length * mArrays.length)
            shrink();
            /* Otherwise, if the size is now an even multiple of the array size,
             * we can drop the very last array.  This is the array whose offset
             * is one after the end of the elements.
             */
        else if (size() % mArrays.length == 0)
            mArrays[computeOffset(size())] = null;

        return result;
    }