private void removeNodeAll( Node<K, V> node ) {
        mAllCount--;
        mModCount++;

        //If we are deleting a node with two children, swap
        //it with a node that has at most one child.
        if( node.mAllLeft != null && node.mAllRight != null ) {
            Node<K, V> swapNode = node.mAllLeft;
            while( swapNode.mAllRight != null ) { swapNode = swapNode.mAllRight; }

            swapNodesAll( node, swapNode );
        }

        //We are now guaranteed that node has no more than one non-null child.
        //We now relabel the node to be deleted "oldParent", the parent of that
        //    deletion node "newParent", and it's child "node".
        Node<K, V> oldParent = node;
        Node<K, V> newParent = node.mAllParent;

        node = (node.mAllLeft == null ? node.mAllRight : node.mAllLeft);

        //Set parent of child node to be newParent.
        if( node != null ) { node.mAllParent = newParent; }

        //Set child of newParent to node.
        if( newParent == null ) {
            mAllRoot = node;

        } else {
            //left = newParent.mLeft == oldParent;
            if( newParent.mAllLeft == oldParent ) {
                newParent.mAllLeft = node;
            } else {
                newParent.mAllRight = node;
            }
        }

        //If oldParent was RED, the constraints will be maintained.
        if( oldParent.mAllColor == RED ) { return; }

        //If the oldParent is BLACK and the node is RED, we swap colors.
        if( node != null && node.mAllColor == RED ) {
            node.mAllColor = BLACK;
            return;
        }

        //If both oldParent and child are black, we're in a world of pain and 
        //must rebalance the tree.
        while( true ) {

            //Case 1: node is new root.  We're done.
            if( newParent == null ) { return; }

            //Case 2: Sibling is RED.  Reverse newParent and sibling colors and 
            //rotate at newParent.  (If tree was balanced before, 
            //sibling is guaranteed to be non-null.)
            boolean    left    = node == newParent.mAllLeft;
            Node<K, V> sibling = left ? newParent.mAllRight : newParent.mAllLeft;

            if( sibling.mAllColor == RED ) {
                newParent.mAllColor = RED;
                sibling.mAllColor = BLACK;

                if( left ) {
                    rotateLeftAll( newParent );
                    sibling = newParent.mAllRight;
                } else {
                    rotateRightAll( newParent );
                    sibling = newParent.mAllLeft;
                }
            }


            if( (sibling.mAllLeft == null || sibling.mAllLeft.mAllColor == BLACK) &&
                (sibling.mAllRight == null || sibling.mAllRight.mAllColor == BLACK) ) {
                if( newParent.mAllColor == BLACK ) {
                    //Case 3: newParent, sibling, and sibling's children are black.
                    //Repaint sibling red and reiterate through loop.
                    sibling.mAllColor = RED;
                    node = newParent;
                    newParent = node.mAllParent;
                    continue;
                } else {
                    //Case 4: sibling and sibling's children are black, but 
                    //newParent is red.  In this case, swap colors between
                    //newParent and sibling.
                    sibling.mAllColor = RED;
                    newParent.mAllColor = BLACK;
                    return;
                }
            }

            //Case 5: sibling is black but has at least one red child.
            //Here we perform a series of rotations to balance out the tree.
            if( left ) {
                if( sibling.mAllRight == null || sibling.mAllRight.mAllColor == BLACK ) {
                    rotateRightAll( sibling );
                    sibling = sibling.mAllParent;
                }

                sibling.mAllColor = newParent.mAllColor;
                sibling.mAllRight.mAllColor = BLACK;
                rotateLeftAll( newParent );

            } else {
                if( sibling.mAllLeft == null || sibling.mAllLeft.mAllColor == BLACK ) {
                    rotateLeftAll( sibling );
                    sibling = sibling.mAllParent;
                }

                sibling.mAllColor = newParent.mAllColor;
                sibling.mAllLeft.mAllColor = BLACK;
                rotateRightAll( newParent );

            }

            newParent.mAllColor = BLACK;
            break;
        }
    }