internal static int allocate(StorageImpl db, int root, Key ins)
            {
                int  pageId = db.allocatePage();
                Page pg     = db.putPage(pageId);

                setnItems(pg, 1);
                setItem(pg, 0, ins.key);
                setItem(pg, maxItems - 1, ins.oid);
                setItem(pg, maxItems - 2, root);
                db.pool.unfix(pg);
                return(pageId);
            }
            internal static BtreeResult remove(StorageImpl db, int pageId, int oid, int height)
            {
                Page pg = db.getPage(pageId);

                try
                {
                    int i, n = getnItems(pg), l = 0, r = n;
                    if (--height == 0)
                    {
                        while (l < r)
                        {
                            i = (l + r) >> 1;
                            if (oid > getItem(pg, maxItems - 1 - i))
                            {
                                l = i + 1;
                            }
                            else
                            {
                                r = i;
                            }
                        }
                        if (r < n && getItem(pg, maxItems - r - 1) == oid)
                        {
                            db.pool.unfix(pg);
                            pg = null;
                            pg = db.putPage(pageId);
                            memcpy(pg, r, pg, r + 1, n - r - 1);
                            memcpy(pg, maxItems - n + 1, pg, maxItems - n, n - r - 1);
                            setnItems(pg, --n);
                            return(n < max / 3 ? BtreeResult.Underflow : BtreeResult.Done);
                        }
                        return(BtreeResult.NotFound);
                    }
                    else
                    {
                        while (l < r)
                        {
                            i = (l + r) >> 1;
                            if (oid > getItem(pg, i))
                            {
                                l = i + 1;
                            }
                            else
                            {
                                r = i;
                            }
                        }
                        BtreeResult result = remove(db, getItem(pg, maxItems - r - 1), oid, height);
                        if (result == BtreeResult.Underflow)
                        {
                            db.pool.unfix(pg);
                            pg = null;
                            pg = db.putPage(pageId);
                            return(handlePageUnderflow(db, pg, r, height));
                        }
                        return(result);
                    }
                }
                finally
                {
                    if (pg != null)
                    {
                        db.pool.unfix(pg);
                    }
                }
            }
            internal static BtreeResult handlePageUnderflow(StorageImpl db, Page pg, int r, int height)
            {
                int  nItems = getnItems(pg);
                Page a      = db.putPage(getItem(pg, maxItems - r - 1));
                int  an     = getnItems(a);

                if (r < nItems)
                { // exists greater page
                    Page b  = db.getPage(getItem(pg, maxItems - r - 2));
                    int  bn = getnItems(b);
                    Debug.Assert(bn >= an);
                    if (height != 1)
                    {
                        memcpy(a, an, pg, r, 1);
                        an += 1;
                        bn += 1;
                    }
                    if (an + bn > max)
                    {
                        // reallocation of nodes between pages a and b
                        int i = bn - ((an + bn) >> 1);
                        db.pool.unfix(b);
                        b = db.putPage(getItem(pg, maxItems - r - 2));
                        memcpy(a, an, b, 0, i);
                        memcpy(b, 0, b, i, bn - i);
                        memcpy(a, maxItems - an - i, b, maxItems - i, i);
                        memcpy(b, maxItems - bn + i, b, maxItems - bn, bn - i);
                        if (height != 1)
                        {
                            memcpy(pg, r, a, an + i - 1, 1);
                        }
                        else
                        {
                            memcpy(pg, r, a, maxItems - an - i, 1);
                        }
                        setnItems(b, getnItems(b) - i);
                        setnItems(a, getnItems(a) + i);
                        db.pool.unfix(a);
                        db.pool.unfix(b);
                        return(BtreeResult.Done);
                    }
                    else
                    { // merge page b to a
                        memcpy(a, an, b, 0, bn);
                        memcpy(a, maxItems - an - bn, b, maxItems - bn, bn);
                        db.freePage(getItem(pg, maxItems - r - 2));
                        memcpy(pg, maxItems - nItems, pg, maxItems - nItems - 1,
                               nItems - r - 1);
                        memcpy(pg, r, pg, r + 1, nItems - r - 1);
                        setnItems(a, getnItems(a) + bn);
                        setnItems(pg, nItems - 1);
                        db.pool.unfix(a);
                        db.pool.unfix(b);
                        return(nItems < max / 3 ? BtreeResult.Underflow : BtreeResult.Done);
                    }
                }
                else
                { // page b is before a
                    Page b  = db.getPage(getItem(pg, maxItems - r));
                    int  bn = getnItems(b);
                    Debug.Assert(bn >= an);
                    if (height != 1)
                    {
                        an += 1;
                        bn += 1;
                    }
                    if (an + bn > max)
                    {
                        // reallocation of nodes between pages a and b
                        int i = bn - ((an + bn) >> 1);
                        db.pool.unfix(b);
                        b = db.putPage(getItem(pg, maxItems - r));
                        memcpy(a, i, a, 0, an);
                        memcpy(a, 0, b, bn - i, i);
                        memcpy(a, maxItems - an - i, a, maxItems - an, an);
                        memcpy(a, maxItems - i, b, maxItems - bn, i);
                        if (height != 1)
                        {
                            memcpy(a, i - 1, pg, r - 1, 1);
                            memcpy(pg, r - 1, b, bn - i - 1, 1);
                        }
                        else
                        {
                            memcpy(pg, r - 1, b, maxItems - bn + i, 1);
                        }
                        setnItems(b, getnItems(b) - i);
                        setnItems(a, getnItems(a) + i);
                        db.pool.unfix(a);
                        db.pool.unfix(b);
                        return(BtreeResult.Done);
                    }
                    else
                    { // merge page b to a
                        memcpy(a, bn, a, 0, an);
                        memcpy(a, 0, b, 0, bn);
                        memcpy(a, maxItems - an - bn, a, maxItems - an, an);
                        memcpy(a, maxItems - bn, b, maxItems - bn, bn);
                        if (height != 1)
                        {
                            memcpy(a, bn - 1, pg, r - 1, 1);
                        }
                        db.freePage(getItem(pg, maxItems - r));
                        setItem(pg, maxItems - r, getItem(pg, maxItems - r - 1));
                        setnItems(a, getnItems(a) + bn);
                        setnItems(pg, nItems - 1);
                        db.pool.unfix(a);
                        db.pool.unfix(b);
                        return(nItems < max / 3 ? BtreeResult.Underflow : BtreeResult.Done);
                    }
                }
            }
            internal static BtreeResult insert(StorageImpl db, int pageId, Key ins, int height)
            {
                Page pg = db.getPage(pageId);
                int  l = 0, n = getnItems(pg), r = n;
                int  oid = ins.oid;

                try
                {
                    if (--height != 0)
                    {
                        while (l < r)
                        {
                            int i = (l + r) >> 1;
                            if (oid > getItem(pg, i))
                            {
                                l = i + 1;
                            }
                            else
                            {
                                r = i;
                            }
                        }
                        Debug.Assert(l == r);
                        /* insert before e[r] */
                        BtreeResult result = insert(db, getItem(pg, maxItems - r - 1), ins, height);
                        Debug.Assert(result != BtreeResult.NotFound);
                        if (result != BtreeResult.Overflow)
                        {
                            return(result);
                        }
                        n += 1;
                    }
                    else
                    {
                        while (l < r)
                        {
                            int i = (l + r) >> 1;
                            if (oid > getItem(pg, maxItems - 1 - i))
                            {
                                l = i + 1;
                            }
                            else
                            {
                                r = i;
                            }
                        }
                        if (r < n && oid == getItem(pg, maxItems - 1 - r))
                        {
                            db.pool.unfix(pg);
                            pg = null;
                            pg = db.putPage(pageId);
                            setItem(pg, r, ins.key);
                            return(BtreeResult.Overwrite);
                        }
                    }
                    db.pool.unfix(pg);
                    pg = null;
                    pg = db.putPage(pageId);
                    if (n < max)
                    {
                        memcpy(pg, r + 1, pg, r, n - r);
                        memcpy(pg, maxItems - n - 1, pg, maxItems - n, n - r);
                        setItem(pg, r, ins.key);
                        setItem(pg, maxItems - 1 - r, ins.oid);
                        setnItems(pg, getnItems(pg) + 1);
                        return(BtreeResult.Done);
                    }
                    else
                    { /* page is full then divide page */
                        pageId = db.allocatePage();
                        Page b = db.putPage(pageId);
                        Debug.Assert(n == max);
                        int m = (max + 1) / 2;
                        if (r < m)
                        {
                            memcpy(b, 0, pg, 0, r);
                            memcpy(b, r + 1, pg, r, m - r - 1);
                            memcpy(pg, 0, pg, m - 1, max - m + 1);
                            memcpy(b, maxItems - r, pg, maxItems - r, r);
                            setItem(b, r, ins.key);
                            setItem(b, maxItems - 1 - r, ins.oid);
                            memcpy(b, maxItems - m, pg, maxItems - m + 1, m - r - 1);
                            memcpy(pg, maxItems - max + m - 1, pg, maxItems - max, max - m + 1);
                        }
                        else
                        {
                            memcpy(b, 0, pg, 0, m);
                            memcpy(pg, 0, pg, m, r - m);
                            memcpy(pg, r - m + 1, pg, r, max - r);
                            memcpy(b, maxItems - m, pg, maxItems - m, m);
                            memcpy(pg, maxItems - r + m, pg, maxItems - r, r - m);
                            setItem(pg, r - m, ins.key);
                            setItem(pg, maxItems - 1 - r + m, ins.oid);
                            memcpy(pg, maxItems - max + m - 1, pg, maxItems - max, max - r);
                        }
                        ins.oid = pageId;
                        if (height == 0)
                        {
                            ins.key = getItem(b, maxItems - m);
                            setnItems(pg, max - m + 1);
                            setnItems(b, m);
                        }
                        else
                        {
                            ins.key = getItem(b, m - 1);
                            setnItems(pg, max - m);
                            setnItems(b, m - 1);
                        }
                        db.pool.unfix(b);
                        return(BtreeResult.Overflow);
                    }
                }
                finally
                {
                    if (pg != null)
                    {
                        db.pool.unfix(pg);
                    }
                }
            }
        internal static BtreeResult insertByteArrayKey(StorageImpl db, Page pg, int r, BtreeKey ins, int height)
        {
            int nItems = getnItems(pg);
            int size = getSize(pg);
            int n = (height != 0)?nItems + 1:nItems;
            // insert before e[r]
            byte[] bval = (byte[])ins.key.oval;        
            int len = bval.Length;
            if (size + len + (n + 1) * strKeySize <= keySpace)
            {
                memcpy(pg, r + 1, pg, r, n - r, strKeySize);
                size += len;
                setKeyStrOffs(pg, r, keySpace - size);
                setKeyStrSize(pg, r, len);
                setKeyStrOid(pg, r, ins.oid);
                setKeyBytes(pg, keySpace - size, bval);
                nItems += 1;
            }
            else
            {
                // page is full then divide page
                int pageId = db.allocatePage();
                Page b = db.putPage(pageId);
                int moved = 0;
                int inserted = len + strKeySize;
                int prevDelta = (1 << 31) + 1;
				
                for (int bn = 0, i = 0; ; bn += 1)
                {
                    int addSize, subSize;
                    int j = nItems - i - 1;
                    int keyLen = getKeyStrSize(pg, i);
                    if (bn == r)
                    {
                        keyLen = len;
                        inserted = 0;
                        addSize = len;
                        if (height == 0)
                        {
                            subSize = 0;
                            j += 1;
                        }
                        else
                        {
                            subSize = getKeyStrSize(pg, i);
                        }
                    }
                    else
                    {
                        addSize = subSize = keyLen;
                        if (height != 0)
                        {
                            if (i + 1 != r)
                            {
                                subSize += getKeyStrSize(pg, i + 1);
                                j -= 1;
                            }
                            else
                            {
                                inserted = 0;
                            }
                        }
                    }
                    int delta = (moved + addSize + (bn + 1) * strKeySize) - (j * strKeySize + size - subSize + inserted);
                    if (delta >= - prevDelta)
                    {
                        if (height == 0)
                        {
                            ins.getByteArray(b, bn - 1);
                        }
                        else
                        {
                            Debug.Assert(moved + (bn + 1) * strKeySize <= keySpace, "String fits in the B-Tree page");
                            if (bn != r)
                            {
                                ins.getByteArray(pg, i);
                                setKeyStrOid(b, bn, getKeyStrOid(pg, i));
                                size -= keyLen;
                                i += 1;
                            }
                            else
                            {
                                setKeyStrOid(b, bn, ins.oid);
                            }
                        }
                        nItems = compactifyByteArrays(pg, i);
                        if (bn < r || (bn == r && height == 0))
                        {
                            memcpy(pg, r - i + 1, pg, r - i, n - r, strKeySize);
                            size += len;
                            nItems += 1;
                            Debug.Assert(size + (n - i + 1) * strKeySize <= keySpace, "String fits in the B-Tree page");
                            setKeyStrOffs(pg, r - i, keySpace - size);
                            setKeyStrSize(pg, r - i, len);
                            setKeyStrOid(pg, r - i, ins.oid);
                            setKeyBytes(pg, keySpace - size, bval);
                        }
                        setnItems(b, bn);
                        setSize(b, moved);
                        setSize(pg, size);
                        setnItems(pg, nItems);
                        ins.oid = pageId;
                        db.pool.unfix(b);
                        return BtreeResult.Overflow;
                    }
                    moved += keyLen;
                    prevDelta = delta;
                    Debug.Assert(moved + (bn + 1) * strKeySize <= keySpace, "String fits in the B-Tree page");
                    setKeyStrSize(b, bn, keyLen);
                    setKeyStrOffs(b, bn, keySpace - moved);
                    if (bn == r)
                    {
                        setKeyStrOid(b, bn, ins.oid);
                        setKeyBytes(b, keySpace - moved, bval);
                    }
                    else
                    {
                        setKeyStrOid(b, bn, getKeyStrOid(pg, i));
                        memcpy(b, keySpace - moved, pg, getKeyStrOffs(pg, i), keyLen, 1);
                        size -= keyLen;
                        i += 1;
                    }
                }
            }
            setnItems(pg, nItems);
            setSize(pg, size);
            return size + strKeySize * (nItems + 1) < keySpace / 3 ? BtreeResult.Underflow : BtreeResult.Done;
        }
 internal static BtreeResult insert(StorageImpl db, int pageId, Btree tree, BtreeKey ins, int height, bool unique, bool overwrite)
 {
     Page pg = db.getPage(pageId);
     BtreeResult result;
     int l = 0, n = getnItems(pg), r = n;
     int ahead = unique ? 1 : 0;
     try
     {
         if (tree.FieldType == ClassDescriptor.FieldType.tpString)
         {
             while (l < r)
             {
                 int i = (l + r) >> 1;
                 if (compareStr(ins.key, pg, i) >= ahead)
                 {
                     l = i + 1;
                 }
                 else
                 {
                     r = i;
                 }
             }
             Debug.Assert(l == r);
             if (--height != 0)
             {
                 result = insert(db, getKeyStrOid(pg, r), tree, ins, height, unique, overwrite);
                 Debug.Assert(result != BtreeResult.NotFound);
                 if (result != BtreeResult.Overflow)
                 {
                     return result;
                 }
             }
             else if (r < n && compareStr(ins.key, pg, r) == 0)
             {
                 if (overwrite) 
                 { 
                     db.pool.unfix(pg);
                     pg = null;
                     pg = db.putPage(pageId);
                     setKeyStrOid(pg, r, ins.oid);
                     return BtreeResult.Overwrite;
                 }
                 else if (unique) 
                 { 
                     return BtreeResult.Duplicate;
                 }
             }
             db.pool.unfix(pg);
             pg = null;
             pg = db.putPage(pageId);
             return insertStrKey(db, pg, r, ins, height);
         }
         else if (tree.FieldType == ClassDescriptor.FieldType.tpArrayOfByte)
         {
             while (l < r)
             {
                 int i = (l + r) >> 1;
                 if (tree.compareByteArrays(ins.key, pg, i) >= ahead)
                 {
                     l = i + 1;
                 }
                 else
                 {
                     r = i;
                 }
             }
             Debug.Assert(l == r);
             if (--height != 0)
             {
                 result = insert(db, getKeyStrOid(pg, r), tree, ins, height, unique, overwrite);
                 Debug.Assert(result != BtreeResult.NotFound);
                 if (result != BtreeResult.Overflow)
                 {
                     return result;
                 }
             }
             else if (r < n && tree.compareByteArrays(ins.key, pg, r) == 0)
             {
                 if (overwrite) 
                 { 
                     db.pool.unfix(pg);
                     pg = null;
                     pg = db.putPage(pageId);
                     setKeyStrOid(pg, r, ins.oid);
                     return BtreeResult.Overwrite;
                 }
                 else if (unique) 
                 { 
                     return BtreeResult.Duplicate;
                 }
             }
             db.pool.unfix(pg);
             pg = null;
             pg = db.putPage(pageId);
             return insertByteArrayKey(db, pg, r, ins, height);
         }
         else
         {
             while (l < r)
             {
                 int i = (l + r) >> 1;
                 if (compare(ins.key, pg, i) >= ahead)
                     l = i + 1;
                 else
                     r = i;
             }
             Debug.Assert(l == r);
             /* insert before e[r] */
             if (--height != 0)
             {
                 result = insert(db, getReference(pg, maxItems - r - 1), tree, ins, height, unique, overwrite);
                 Debug.Assert(result != BtreeResult.NotFound);
                 if (result != BtreeResult.Overflow)
                 {
                     return result;
                 }
                 n += 1;
             }
             else if (r < n && compare(ins.key, pg, r) == 0)
             {
                 if (overwrite) 
                 { 
                     db.pool.unfix(pg);
                     pg = null;
                     pg = db.putPage(pageId);
                     setReference(pg, maxItems - r - 1, ins.oid);
                     return BtreeResult.Overwrite;
                 }
                 else if (unique) 
                 { 
                     return BtreeResult.Duplicate;
                 }
             }
             db.pool.unfix(pg);
             pg = null;
             pg = db.putPage(pageId);
             int itemSize = ClassDescriptor.Sizeof[(int)tree.FieldType];
             int max = keySpace / (4 + itemSize);
             if (n < max)
             {
                 memcpy(pg, r + 1, pg, r, n - r, itemSize);
                 memcpy(pg, maxItems - n - 1, pg, maxItems - n, n - r, 4);
                 ins.pack(pg, r);
                 setnItems(pg, getnItems(pg) + 1);
                 return BtreeResult.Done;
             }
             else
             {
                 /* page is full then divide page */
                 pageId = db.allocatePage();
                 Page b = db.putPage(pageId);
                 Debug.Assert(n == max);
                 int m = (max + 1) / 2;
                 if (r < m)
                 {
                     memcpy(b, 0, pg, 0, r, itemSize);
                     memcpy(b, r + 1, pg, r, m - r - 1, itemSize);
                     memcpy(pg, 0, pg, m - 1, max - m + 1, itemSize);
                     memcpy(b, maxItems - r, pg, maxItems - r, r, 4);
                     ins.pack(b, r);
                     memcpy(b, maxItems - m, pg, maxItems - m + 1, m - r - 1, 4);
                     memcpy(pg, maxItems - max + m - 1, pg, maxItems - max, max - m + 1, 4);
                 }
                 else
                 {
                     memcpy(b, 0, pg, 0, m, itemSize);
                     memcpy(pg, 0, pg, m, r - m, itemSize);
                     memcpy(pg, r - m + 1, pg, r, max - r, itemSize);
                     memcpy(b, maxItems - m, pg, maxItems - m, m, 4);
                     memcpy(pg, maxItems - r + m, pg, maxItems - r, r - m, 4);
                     ins.pack(pg, r - m);
                     memcpy(pg, maxItems - max + m - 1, pg, maxItems - max, max - r, 4);
                 }
                 ins.oid = pageId;
                 ins.extract(b, firstKeyOffs + (m - 1) * itemSize, tree.FieldType);
                 if (height == 0)
                 {
                     setnItems(pg, max - m + 1);
                     setnItems(b, m);
                 }
                 else
                 {
                     setnItems(pg, max - m);
                     setnItems(b, m - 1);
                 }
                 db.pool.unfix(b);
                 return BtreeResult.Overflow;
             }
         }
     }
     finally
     {
         if (pg != null) 
         { 
             db.pool.unfix(pg);
         }
     }
 }
 internal static int allocate(StorageImpl db, int root, ClassDescriptor.FieldType type, BtreeKey ins)
 {
     int pageId = db.allocatePage();
     Page pg = db.putPage(pageId);
     setnItems(pg, 1);
     if (type == ClassDescriptor.FieldType.tpString)
     {
         char[] sval = (char[])ins.key.oval;
         int len = sval.Length;
         setSize(pg, len * 2);
         setKeyStrOffs(pg, 0, keySpace - len * 2);
         setKeyStrSize(pg, 0, len);
         setKeyStrOid(pg, 0, ins.oid);
         setKeyStrOid(pg, 1, root);
         setKeyStrChars(pg, keySpace - len * 2, sval);
     }
     else if (type == ClassDescriptor.FieldType.tpArrayOfByte)
     {
         byte[] bval = (byte[])ins.key.oval;
         int len = bval.Length;
         setSize(pg, len);
         setKeyStrOffs(pg, 0, keySpace - len);
         setKeyStrSize(pg, 0, len);
         setKeyStrOid(pg, 0, ins.oid);
         setKeyStrOid(pg, 1, root);
         setKeyBytes(pg, keySpace - len, bval);
     }
     else
     {
         ins.pack(pg, 0);
         setReference(pg, maxItems - 2, root);
     }
     db.pool.unfix(pg);
     return pageId;
 }
        internal static BtreeResult remove(StorageImpl db, int pageId, Btree tree, BtreeKey rem, int height)
        {
            Page pg = db.getPage(pageId);
            try
            {
                int i, n = getnItems(pg), l = 0, r = n;
				
                if (tree.FieldType == ClassDescriptor.FieldType.tpString)
                {
                    while (l < r)
                    {
                        i = (l + r) >> 1;
                        if (compareStr(rem.key, pg, i) > 0)
                        {
                            l = i + 1;
                        }
                        else
                        {
                            r = i;
                        }
                    }
                    if (--height != 0)
                    {
                        do 
                        {
                            switch (remove(db, getKeyStrOid(pg, r), tree, rem, height))
                            {
                                case BtreeResult.Underflow: 
                                    db.pool.unfix(pg);
                                    pg = null;
                                    pg = db.putPage(pageId);
                                    return handlePageUnderflow(db, pg, r, tree.FieldType, rem, height);
								
                                case BtreeResult.Done: 
                                    return BtreeResult.Done;
								
                                case BtreeResult.Overflow: 
                                    db.pool.unfix(pg);
                                    pg = null;
                                    pg = db.putPage(pageId);
                                    return insertStrKey(db, pg, r, rem, height);
								
                            }
                        }
                        while (++r <= n);
                    }
                    else
                    {
                        while (r < n)
                        {
                            if (compareStr(rem.key, pg, r) == 0)
                            {
                                int oid = getKeyStrOid(pg, r);
                                if (oid == rem.oid || rem.oid == 0)
                                {
                                    rem.oldOid = oid;
                                    db.pool.unfix(pg);
                                    pg = null;
                                    pg = db.putPage(pageId);
                                    return removeStrKey(pg, r);
                                }
                            }
                            else
                            {
                                break;
                            }
                            r += 1;
                        }
                    }
                } 
                else if (tree.FieldType == ClassDescriptor.FieldType.tpArrayOfByte)
                {
                    while (l < r)
                    {
                        i = (l + r) >> 1;
                        if (tree.compareByteArrays(rem.key, pg, i) > 0)
                        {
                            l = i + 1;
                        }
                        else
                        {
                            r = i;
                        }
                    }
                    if (--height != 0)
                    {
                        do 
                        {
                            switch (remove(db, getKeyStrOid(pg, r), tree, rem, height))
                            {
                                case BtreeResult.Underflow: 
                                    db.pool.unfix(pg);
                                    pg = null;
                                    pg = db.putPage(pageId);
                                    return handlePageUnderflow(db, pg, r, tree.FieldType, rem, height);
								
                                case BtreeResult.Done: 
                                    return BtreeResult.Done;
								
                                case BtreeResult.Overflow: 
                                    db.pool.unfix(pg);
                                    pg = null;
                                    pg = db.putPage(pageId);
                                    return insertByteArrayKey(db, pg, r, rem, height);
								
                            }
                        }
                        while (++r <= n);
                    }
                    else
                    {
                        while (r < n)
                        {
                            if (tree.compareByteArrays(rem.key, pg, r) == 0)
                            {
                                int oid = getKeyStrOid(pg, r);
                                if (oid == rem.oid || rem.oid == 0)
                                {
                                    rem.oldOid = oid;
                                    db.pool.unfix(pg);
                                    pg = null;
                                    pg = db.putPage(pageId);
                                    return removeByteArrayKey(pg, r);
                                }
                            }
                            else
                            {
                                break;
                            }
                            r += 1;
                        }
                    }
                } 
                else // scalars
                {
                    int itemSize = ClassDescriptor.Sizeof[(int)tree.FieldType];
                    while (l < r)
                    {
                        i = (l + r) >> 1;
                        if (compare(rem.key, pg, i) > 0)
                        {
                            l = i + 1;
                        }
                        else
                        {
                            r = i;
                        }
                    }
                    if (--height == 0)
                    {
                        int oid = rem.oid;
                        while (r < n)
                        {
                            if (compare(rem.key, pg, r) == 0)
                            {
                                if (getReference(pg, maxItems - r - 1) == oid || oid == 0)
                                {
                                    rem.oldOid = getReference(pg, maxItems - r - 1);
                                    db.pool.unfix(pg);
                                    pg = null;
                                    pg = db.putPage(pageId);
                                    memcpy(pg, r, pg, r + 1, n - r - 1, itemSize);
                                    memcpy(pg, maxItems - n + 1, pg, maxItems - n, n - r - 1, 4);
                                    setnItems(pg, --n);
                                    return n * (itemSize + 4) < keySpace / 3 ? BtreeResult.Underflow : BtreeResult.Done;
                                }
                            }
                            else
                            {
                                break;
                            }
                            r += 1;
                        }
                        return BtreeResult.NotFound;
                    }
                    do 
                    {
                        switch (remove(db, getReference(pg, maxItems - r - 1), tree, rem, height))
                        {
                            case BtreeResult.Underflow: 
                                db.pool.unfix(pg);
                                pg = db.putPage(pageId);
                                return handlePageUnderflow(db, pg, r, tree.FieldType, rem, height);
							
                            case BtreeResult.Done: 
                                return BtreeResult.Done;
							
                        }
                    }
                    while (++r <= n);
                }
                return BtreeResult.NotFound;
            }
            finally
            {
                if (pg != null) 
                {
                    db.pool.unfix(pg);

                }
            }
        }
 internal static BtreeResult handlePageUnderflow(StorageImpl db, Page pg, int r, ClassDescriptor.FieldType type, BtreeKey rem, int height)
 {
     int nItems = getnItems(pg);
     if (type == ClassDescriptor.FieldType.tpString)
     {
         Page a = db.putPage(getKeyStrOid(pg, r));
         int an = getnItems(a);
         if (r < nItems)
         {
             // exists greater page
             Page b = db.getPage(getKeyStrOid(pg, r + 1));
             int bn = getnItems(b);
             int merged_size = (an + bn) * strKeySize + getSize(a) + getSize(b);
             if (height != 1)
             {
                 merged_size += getKeyStrSize(pg, r) * 2 + strKeySize * 2;
             }
             if (merged_size > keySpace)
             {
                 // reallocation of nodes between pages a and b
                 int i, j, k;
                 db.pool.unfix(b);
                 b = db.putPage(getKeyStrOid(pg, r + 1));
                 int size_a = getSize(a);
                 int size_b = getSize(b);
                 int addSize, subSize;
                 if (height != 1)
                 {
                     addSize = getKeyStrSize(pg, r);
                     subSize = getKeyStrSize(b, 0);
                 }
                 else
                 {
                     addSize = subSize = getKeyStrSize(b, 0);
                 }
                 i = 0;
                 int prevDelta = (an * strKeySize + size_a) - (bn * strKeySize + size_b);
                 while (true)
                 {
                     i += 1;
                     int delta = ((an + i) * strKeySize + size_a + addSize * 2) - ((bn - i) * strKeySize + size_b - subSize * 2);
                     if (delta >= 0)
                     {
                         if (delta >= - prevDelta)
                         {
                             i -= 1;
                         }
                         break;
                     }
                     size_a += addSize * 2;
                     size_b -= subSize * 2;
                     prevDelta = delta;
                     if (height != 1)
                     {
                         addSize = subSize;
                         subSize = getKeyStrSize(b, i);
                     }
                     else
                     {
                         addSize = subSize = getKeyStrSize(b, i);
                     }
                 }
                 BtreeResult result = BtreeResult.Done;
                 if (i > 0)
                 {
                     k = i;
                     if (height != 1)
                     {
                         int len = getKeyStrSize(pg, r);
                         setSize(a, getSize(a) + len * 2);
                         setKeyStrOffs(a, an, keySpace - getSize(a));
                         setKeyStrSize(a, an, len);
                         memcpy(a, getKeyStrOffs(a, an), pg, getKeyStrOffs(pg, r), len * 2, 1);
                         k -= 1;
                         an += 1;
                         setKeyStrOid(a, an + k, getKeyStrOid(b, k));
                         setSize(b, getSize(b) - getKeyStrSize(b, k) * 2);
                     }
                     for (j = 0; j < k; j++)
                     {
                         int len = getKeyStrSize(b, j);
                         setSize(a, getSize(a) + len * 2);
                         setSize(b, getSize(b) - len * 2);
                         setKeyStrOffs(a, an, keySpace - getSize(a));
                         setKeyStrSize(a, an, len);
                         setKeyStrOid(a, an, getKeyStrOid(b, j));
                         memcpy(a, getKeyStrOffs(a, an), b, getKeyStrOffs(b, j), len * 2, 1);
                         an += 1;
                     }
                     rem.getStr(b, i - 1);
                     result = replaceStrKey(db, pg, r, rem, height);
                     setnItems(a, an);
                     setnItems(b, compactifyStrings(b, i));
                 }
                 db.pool.unfix(a);
                 db.pool.unfix(b);
                 return result;
             }
             else
             {
                 // merge page b to a
                 if (height != 1)
                 {
                     int r_len = getKeyStrSize(pg, r);
                     setKeyStrSize(a, an, r_len);
                     setSize(a, getSize(a) + r_len * 2);
                     setKeyStrOffs(a, an, keySpace - getSize(a));
                     memcpy(a, getKeyStrOffs(a, an), pg, getKeyStrOffs(pg, r), r_len * 2, 1);
                     an += 1;
                     setKeyStrOid(a, an + bn, getKeyStrOid(b, bn));
                 }
                 for (int i = 0; i < bn; i++, an++)
                 {
                     setKeyStrSize(a, an, getKeyStrSize(b, i));
                     setKeyStrOffs(a, an, getKeyStrOffs(b, i) - getSize(a));
                     setKeyStrOid(a, an, getKeyStrOid(b, i));
                 }
                 setSize(a, getSize(a) + getSize(b));
                 setnItems(a, an);
                 memcpy(a, keySpace - getSize(a), b, keySpace - getSize(b), getSize(b), 1);
                 db.pool.unfix(a);
                 db.pool.unfix(b);
                 db.freePage(getKeyStrOid(pg, r + 1));
                 setKeyStrOid(pg, r + 1, getKeyStrOid(pg, r));
                 return removeStrKey(pg, r);
             }
         }
         else
         {
             // page b is before a
             Page b = db.getPage(getKeyStrOid(pg, r - 1));
             int bn = getnItems(b);
             int merged_size = (an + bn) * strKeySize + getSize(a) + getSize(b);
             if (height != 1)
             {
                 merged_size += getKeyStrSize(pg, r - 1) * 2 + strKeySize * 2;
             }
             if (merged_size > keySpace)
             {
                 // reallocation of nodes between pages a and b
                 int i, j, k, len;
                 db.pool.unfix(b);
                 b = db.putPage(getKeyStrOid(pg, r - 1));
                 int size_a = getSize(a);
                 int size_b = getSize(b);
                 int addSize, subSize;
                 if (height != 1)
                 {
                     addSize = getKeyStrSize(pg, r - 1);
                     subSize = getKeyStrSize(b, bn - 1);
                 }
                 else
                 {
                     addSize = subSize = getKeyStrSize(b, bn - 1);
                 }
                 i = 0;
                 int prevDelta = (an * strKeySize + size_a) - (bn * strKeySize + size_b);
                 while (true)
                 {
                     i += 1;
                     int delta = ((an + i) * strKeySize + size_a + addSize * 2) - ((bn - i) * strKeySize + size_b - subSize * 2);
                     if (delta >= 0)
                     {
                         if (delta >= - prevDelta)
                         {
                             i -= 1;
                         }
                         break;
                     }
                     prevDelta = delta;
                     size_a += addSize * 2;
                     size_b -= subSize * 2;
                     if (height != 1)
                     {
                         addSize = subSize;
                         subSize = getKeyStrSize(b, bn - i - 1);
                     }
                     else
                     {
                         addSize = subSize = getKeyStrSize(b, bn - i - 1);
                     }
                 }
                 BtreeResult result = BtreeResult.Done;
                 if (i > 0)
                 {
                     k = i;
                     Debug.Assert(i < bn);
                     if (height != 1)
                     {
                         setSize(b, getSize(b) - getKeyStrSize(b, bn - k) * 2);
                         memcpy(a, i, a, 0, an + 1, strKeySize);
                         k -= 1;
                         setKeyStrOid(a, k, getKeyStrOid(b, bn));
                         len = getKeyStrSize(pg, r - 1);
                         setKeyStrSize(a, k, len);
                         setSize(a, getSize(a) + len * 2);
                         setKeyStrOffs(a, k, keySpace - getSize(a));
                         memcpy(a, getKeyStrOffs(a, k), pg, getKeyStrOffs(pg, r - 1), len * 2, 1);
                     }
                     else
                     {
                         memcpy(a, i, a, 0, an, strKeySize);
                     }
                     for (j = 0; j < k; j++)
                     {
                         len = getKeyStrSize(b, bn - k + j);
                         setSize(a, getSize(a) + len * 2);
                         setSize(b, getSize(b) - len * 2);
                         setKeyStrOffs(a, j, keySpace - getSize(a));
                         setKeyStrSize(a, j, len);
                         setKeyStrOid(a, j, getKeyStrOid(b, bn - k + j));
                         memcpy(a, getKeyStrOffs(a, j), b, getKeyStrOffs(b, bn - k + j), len * 2, 1);
                     }
                     an += i;
                     setnItems(a, an);
                     rem.getStr(b, bn - k - 1);
                     result = replaceStrKey(db, pg, r - 1, rem, height);
                     setnItems(b, compactifyStrings(b, - i));
                 }
                 db.pool.unfix(a);
                 db.pool.unfix(b);
                 return result;
             }
             else
             {
                 // merge page b to a
                 if (height != 1)
                 {
                     memcpy(a, bn + 1, a, 0, an + 1, strKeySize);
                     int len = getKeyStrSize(pg, r - 1);
                     setKeyStrSize(a, bn, len);
                     setSize(a, getSize(a) + len * 2);
                     setKeyStrOffs(a, bn, keySpace - getSize(a));
                     setKeyStrOid(a, bn, getKeyStrOid(b, bn));
                     memcpy(a, getKeyStrOffs(a, bn), pg, getKeyStrOffs(pg, r - 1), len * 2, 1);
                     an += 1;
                 }
                 else
                 {
                     memcpy(a, bn, a, 0, an, strKeySize);
                 }
                 for (int i = 0; i < bn; i++)
                 {
                     setKeyStrOid(a, i, getKeyStrOid(b, i));
                     setKeyStrSize(a, i, getKeyStrSize(b, i));
                     setKeyStrOffs(a, i, getKeyStrOffs(b, i) - getSize(a));
                 }
                 an += bn;
                 setnItems(a, an);
                 setSize(a, getSize(a) + getSize(b));
                 memcpy(a, keySpace - getSize(a), b, keySpace - getSize(b), getSize(b), 1);
                 db.pool.unfix(a);
                 db.pool.unfix(b);
                 db.freePage(getKeyStrOid(pg, r - 1));
                 return removeStrKey(pg, r - 1);
             }
         }
     }
     else if (type == ClassDescriptor.FieldType.tpArrayOfByte)
     {
         Page a = db.putPage(getKeyStrOid(pg, r));
         int an = getnItems(a);
         if (r < nItems)
         {
             // exists greater page
             Page b = db.getPage(getKeyStrOid(pg, r + 1));
             int bn = getnItems(b);
             int merged_size = (an + bn) * strKeySize + getSize(a) + getSize(b);
             if (height != 1)
             {
                 merged_size += getKeyStrSize(pg, r) + strKeySize * 2;
             }
             if (merged_size > keySpace)
             {
                 // reallocation of nodes between pages a and b
                 int i, j, k;
                 db.pool.unfix(b);
                 b = db.putPage(getKeyStrOid(pg, r + 1));
                 int size_a = getSize(a);
                 int size_b = getSize(b);
                 int addSize, subSize;
                 if (height != 1)
                 {
                     addSize = getKeyStrSize(pg, r);
                     subSize = getKeyStrSize(b, 0);
                 }
                 else
                 {
                     addSize = subSize = getKeyStrSize(b, 0);
                 }
                 i = 0;
                 int prevDelta = (an * strKeySize + size_a) - (bn * strKeySize + size_b);
                 while (true)
                 {
                     i += 1;
                     int delta = ((an + i) * strKeySize + size_a + addSize) - ((bn - i) * strKeySize + size_b - subSize);
                     if (delta >= 0)
                     {
                         if (delta >= - prevDelta)
                         {
                             i -= 1;
                         }
                         break;
                     }
                     size_a += addSize;
                     size_b -= subSize;
                     prevDelta = delta;
                     if (height != 1)
                     {
                         addSize = subSize;
                         subSize = getKeyStrSize(b, i);
                     }
                     else
                     {
                         addSize = subSize = getKeyStrSize(b, i);
                     }
                 }
                 BtreeResult result = BtreeResult.Done;
                 if (i > 0)
                 {
                     k = i;
                     if (height != 1)
                     {
                         int len = getKeyStrSize(pg, r);
                         setSize(a, getSize(a) + len);
                         setKeyStrOffs(a, an, keySpace - getSize(a));
                         setKeyStrSize(a, an, len);
                         memcpy(a, getKeyStrOffs(a, an), pg, getKeyStrOffs(pg, r), len, 1);
                         k -= 1;
                         an += 1;
                         setKeyStrOid(a, an + k, getKeyStrOid(b, k));
                         setSize(b, getSize(b) - getKeyStrSize(b, k));
                     }
                     for (j = 0; j < k; j++)
                     {
                         int len = getKeyStrSize(b, j);
                         setSize(a, getSize(a) + len);
                         setSize(b, getSize(b) - len);
                         setKeyStrOffs(a, an, keySpace - getSize(a));
                         setKeyStrSize(a, an, len);
                         setKeyStrOid(a, an, getKeyStrOid(b, j));
                         memcpy(a, getKeyStrOffs(a, an), b, getKeyStrOffs(b, j), len, 1);
                         an += 1;
                     }
                     rem.getByteArray(b, i - 1);
                     result = replaceByteArrayKey(db, pg, r, rem, height);
                     setnItems(a, an);
                     setnItems(b, compactifyByteArrays(b, i));
                 }
                 db.pool.unfix(a);
                 db.pool.unfix(b);
                 return result;
             }
             else
             {
                 // merge page b to a
                 if (height != 1)
                 {
                     int r_len = getKeyStrSize(pg, r);
                     setKeyStrSize(a, an, r_len);
                     setSize(a, getSize(a) + r_len);
                     setKeyStrOffs(a, an, keySpace - getSize(a));
                     memcpy(a, getKeyStrOffs(a, an), pg, getKeyStrOffs(pg, r), r_len, 1);
                     an += 1;
                     setKeyStrOid(a, an + bn, getKeyStrOid(b, bn));
                 }
                 for (int i = 0; i < bn; i++, an++)
                 {
                     setKeyStrSize(a, an, getKeyStrSize(b, i));
                     setKeyStrOffs(a, an, getKeyStrOffs(b, i) - getSize(a));
                     setKeyStrOid(a, an, getKeyStrOid(b, i));
                 }
                 setSize(a, getSize(a) + getSize(b));
                 setnItems(a, an);
                 memcpy(a, keySpace - getSize(a), b, keySpace - getSize(b), getSize(b), 1);
                 db.pool.unfix(a);
                 db.pool.unfix(b);
                 db.freePage(getKeyStrOid(pg, r + 1));
                 setKeyStrOid(pg, r + 1, getKeyStrOid(pg, r));
                 return removeByteArrayKey(pg, r);
             }
         }
         else
         {
             // page b is before a
             Page b = db.getPage(getKeyStrOid(pg, r - 1));
             int bn = getnItems(b);
             int merged_size = (an + bn) * strKeySize + getSize(a) + getSize(b);
             if (height != 1)
             {
                 merged_size += getKeyStrSize(pg, r - 1) + strKeySize * 2;
             }
             if (merged_size > keySpace)
             {
                 // reallocation of nodes between pages a and b
                 int i, j, k, len;
                 db.pool.unfix(b);
                 b = db.putPage(getKeyStrOid(pg, r - 1));
                 int size_a = getSize(a);
                 int size_b = getSize(b);
                 int addSize, subSize;
                 if (height != 1)
                 {
                     addSize = getKeyStrSize(pg, r - 1);
                     subSize = getKeyStrSize(b, bn - 1);
                 }
                 else
                 {
                     addSize = subSize = getKeyStrSize(b, bn - 1);
                 }
                 i = 0;
                 int prevDelta = (an * strKeySize + size_a) - (bn * strKeySize + size_b);
                 while (true)
                 {
                     i += 1;
                     int delta = ((an + i) * strKeySize + size_a + addSize) - ((bn - i) * strKeySize + size_b - subSize);
                     if (delta >= 0)
                     {
                         if (delta >= - prevDelta)
                         {
                             i -= 1;
                         }
                         break;
                     }
                     prevDelta = delta;
                     size_a += addSize;
                     size_b -= subSize;
                     if (height != 1)
                     {
                         addSize = subSize;
                         subSize = getKeyStrSize(b, bn - i - 1);
                     }
                     else
                     {
                         addSize = subSize = getKeyStrSize(b, bn - i - 1);
                     }
                 }
                 BtreeResult result = BtreeResult.Done;
                 if (i > 0)
                 {
                     k = i;
                     Debug.Assert(i < bn);
                     if (height != 1)
                     {
                         setSize(b, getSize(b) - getKeyStrSize(b, bn - k));
                         memcpy(a, i, a, 0, an + 1, strKeySize);
                         k -= 1;
                         setKeyStrOid(a, k, getKeyStrOid(b, bn));
                         len = getKeyStrSize(pg, r - 1);
                         setKeyStrSize(a, k, len);
                         setSize(a, getSize(a) + len);
                         setKeyStrOffs(a, k, keySpace - getSize(a));
                         memcpy(a, getKeyStrOffs(a, k), pg, getKeyStrOffs(pg, r - 1), len, 1);
                     }
                     else
                     {
                         memcpy(a, i, a, 0, an, strKeySize);
                     }
                     for (j = 0; j < k; j++)
                     {
                         len = getKeyStrSize(b, bn - k + j);
                         setSize(a, getSize(a) + len);
                         setSize(b, getSize(b) - len);
                         setKeyStrOffs(a, j, keySpace - getSize(a));
                         setKeyStrSize(a, j, len);
                         setKeyStrOid(a, j, getKeyStrOid(b, bn - k + j));
                         memcpy(a, getKeyStrOffs(a, j), b, getKeyStrOffs(b, bn - k + j), len, 1);
                     }
                     an += i;
                     setnItems(a, an);
                     rem.getByteArray(b, bn - k - 1);
                     result = replaceByteArrayKey(db, pg, r - 1, rem, height);
                     setnItems(b, compactifyByteArrays(b, - i));
                 }
                 db.pool.unfix(a);
                 db.pool.unfix(b);
                 return result;
             }
             else
             {
                 // merge page b to a
                 if (height != 1)
                 {
                     memcpy(a, bn + 1, a, 0, an + 1, strKeySize);
                     int len = getKeyStrSize(pg, r - 1);
                     setKeyStrSize(a, bn, len);
                     setSize(a, getSize(a) + len);
                     setKeyStrOffs(a, bn, keySpace - getSize(a));
                     setKeyStrOid(a, bn, getKeyStrOid(b, bn));
                     memcpy(a, getKeyStrOffs(a, bn), pg, getKeyStrOffs(pg, r - 1), len, 1);
                     an += 1;
                 }
                 else
                 {
                     memcpy(a, bn, a, 0, an, strKeySize);
                 }
                 for (int i = 0; i < bn; i++)
                 {
                     setKeyStrOid(a, i, getKeyStrOid(b, i));
                     setKeyStrSize(a, i, getKeyStrSize(b, i));
                     setKeyStrOffs(a, i, getKeyStrOffs(b, i) - getSize(a));
                 }
                 an += bn;
                 setnItems(a, an);
                 setSize(a, getSize(a) + getSize(b));
                 memcpy(a, keySpace - getSize(a), b, keySpace - getSize(b), getSize(b), 1);
                 db.pool.unfix(a);
                 db.pool.unfix(b);
                 db.freePage(getKeyStrOid(pg, r - 1));
                 return removeByteArrayKey(pg, r - 1);
             }
         }
     }
     else
     {
         Page a = db.putPage(getReference(pg, maxItems - r - 1));
         int an = getnItems(a);
         int itemSize = ClassDescriptor.Sizeof[(int)type];
         if (r < nItems)
         {
             // exists greater page
             Page b = db.getPage(getReference(pg, maxItems - r - 2));
             int bn = getnItems(b);
             Debug.Assert(bn >= an);
             if (height != 1)
             {
                 memcpy(a, an, pg, r, 1, itemSize);
                 an += 1;
                 bn += 1;
             }
             int merged_size = (an + bn) * (4 + itemSize);
             if (merged_size > keySpace)
             {
                 // reallocation of nodes between pages a and b
                 int i = bn - ((an + bn) >> 1);
                 db.pool.unfix(b);
                 b = db.putPage(getReference(pg, maxItems - r - 2));
                 memcpy(a, an, b, 0, i, itemSize);
                 memcpy(b, 0, b, i, bn - i, itemSize);
                 memcpy(a, maxItems - an - i, b, maxItems - i, i, 4);
                 memcpy(b, maxItems - bn + i, b, maxItems - bn, bn - i, 4);
                 memcpy(pg, r, a, an + i - 1, 1, itemSize);
                 setnItems(b, getnItems(b) - i);
                 setnItems(a, getnItems(a) + i);
                 db.pool.unfix(a);
                 db.pool.unfix(b);
                 return BtreeResult.Done;
             }
             else
             {
                 // merge page b to a  
                 memcpy(a, an, b, 0, bn, itemSize);
                 memcpy(a, maxItems - an - bn, b, maxItems - bn, bn, 4);
                 db.freePage(getReference(pg, maxItems - r - 2));
                 memcpy(pg, maxItems - nItems, pg, maxItems - nItems - 1, nItems - r - 1, 4);
                 memcpy(pg, r, pg, r + 1, nItems - r - 1, itemSize);
                 setnItems(a, getnItems(a) + bn);
                 setnItems(pg, nItems - 1);
                 db.pool.unfix(a);
                 db.pool.unfix(b);
                 return nItems * (itemSize + 4) < keySpace / 3 ? BtreeResult.Underflow : BtreeResult.Done;
             }
         }
         else
         {
             // page b is before a
             Page b = db.getPage(getReference(pg, maxItems - r));
             int bn = getnItems(b);
             Debug.Assert(bn >= an);
             if (height != 1)
             {
                 an += 1;
                 bn += 1;
             }
             int merged_size = (an + bn) * (4 + itemSize);
             if (merged_size > keySpace)
             {
                 // reallocation of nodes between pages a and b
                 int i = bn - ((an + bn) >> 1);
                 db.pool.unfix(b);
                 b = db.putPage(getReference(pg, maxItems - r));
                 memcpy(a, i, a, 0, an, itemSize);
                 memcpy(a, 0, b, bn - i, i, itemSize);
                 memcpy(a, maxItems - an - i, a, maxItems - an, an, 4);
                 memcpy(a, maxItems - i, b, maxItems - bn, i, 4);
                 if (height != 1)
                 {
                     memcpy(a, i - 1, pg, r - 1, 1, itemSize);
                 }
                 memcpy(pg, r - 1, b, bn - i - 1, 1, itemSize);
                 setnItems(b, getnItems(b) - i);
                 setnItems(a, getnItems(a) + i);
                 db.pool.unfix(a);
                 db.pool.unfix(b);
                 return BtreeResult.Done;
             }
             else
             {
                 // merge page b to a
                 memcpy(a, bn, a, 0, an, itemSize);
                 memcpy(a, 0, b, 0, bn, itemSize);
                 memcpy(a, maxItems - an - bn, a, maxItems - an, an, 4);
                 memcpy(a, maxItems - bn, b, maxItems - bn, bn, 4);
                 if (height != 1)
                 {
                     memcpy(a, bn - 1, pg, r - 1, 1, itemSize);
                 }
                 db.freePage(getReference(pg, maxItems - r));
                 setReference(pg, maxItems - r, getReference(pg, maxItems - r - 1));
                 setnItems(a, getnItems(a) + bn);
                 setnItems(pg, nItems - 1);
                 db.pool.unfix(a);
                 db.pool.unfix(b);
                 return nItems * (itemSize + 4) < keySpace / 3 ? BtreeResult.Underflow : BtreeResult.Done;
             }
         }
     }
 }