private void removeNodeGroup( GroupNode<K, V> group, Node<K, V> node ) {
        mModCount++;
        group.mSize--;

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

            swapNodesGroup( group, 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.mGroupParent;

        node = (node.mGroupLeft == null ? node.mGroupRight : node.mGroupLeft);

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

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

        } else {
            //left = newParent.mGroupLeft == oldParent;
            if( newParent.mGroupLeft == oldParent ) {
                newParent.mGroupLeft = node;
            } else {
                newParent.mGroupRight = node;
            }
        }

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

        //If the oldParent is BLACK and the node is RED, we swap colors.
        if( node != null && node.mGroupColor == RED ) {
            node.mGroupColor = 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.mGroupLeft;
            Node<K, V> sibling = left ? newParent.mGroupRight : newParent.mGroupLeft;

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

                if( left ) {
                    rotateLeftGroup( group, newParent );
                    sibling = newParent.mGroupRight;
                } else {
                    rotateRightGroup( group, newParent );
                    sibling = newParent.mGroupLeft;
                }
            }


            if( (sibling.mGroupLeft == null || sibling.mGroupLeft.mGroupColor == BLACK) &&
                (sibling.mGroupRight == null || sibling.mGroupRight.mGroupColor == BLACK) ) {
                if( newParent.mGroupColor == BLACK ) {
                    //Case 3: newParent, sibling, and sibling's children are black.
                    //Repaint sibling red and reiterate through loop.
                    sibling.mGroupColor = RED;
                    node = newParent;
                    newParent = node.mGroupParent;
                    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.mGroupColor = RED;
                    newParent.mGroupColor = 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.mGroupRight == null || sibling.mGroupRight.mGroupColor == BLACK ) {
                    rotateRightGroup( group, sibling );
                    sibling = sibling.mGroupParent;
                }

                sibling.mGroupColor = newParent.mGroupColor;
                sibling.mGroupRight.mGroupColor = BLACK;
                rotateLeftGroup( group, newParent );

            } else {
                if( sibling.mGroupLeft == null || sibling.mGroupLeft.mGroupColor == BLACK ) {
                    rotateLeftGroup( group, sibling );
                    sibling = sibling.mGroupParent;
                }

                sibling.mGroupColor = newParent.mGroupColor;
                sibling.mGroupLeft.mGroupColor = BLACK;
                rotateRightGroup( group, newParent );

            }

            newParent.mGroupColor = BLACK;
            break;
        }
    }