if ((vmt == FREE) && (nextOffset < size)) {
if ((vmt == FREE) && (nextOffset.LT(size))) {
    protected final void defragment() throws UninterruptiblePragma {        final int size = getSize();        int offset = headerSize;        final Offset sizeOffset = this.sizeOffset;        final Offset tibOffset = this.tibOffset;        lock();        try {            Address firstFreePtr = null;            while (offset < size) {                final Address ptr = start.add(offset);                final int objSize = ptr.loadInt(sizeOffset);                final int nextOffset = offset + objSize + headerSize;                final Object vmt = ptr.loadObjectReference(tibOffset);                if ((firstFreePtr == null) && (vmt == FREE)) {                    firstFreePtr = ptr;                }                if ((vmt == FREE) && (nextOffset < size)) {                    final Object nextVmt;                    final Address nextObjectPtr = start.add(nextOffset);                    nextVmt = nextObjectPtr.loadObjectReference(tibOffset);                    if (nextVmt == FREE) {                        // Combine two free spaces                        int nextObjSize = nextObjectPtr.loadInt(sizeOffset);                        int newObjSize = objSize + headerSize + nextObjSize;                        ptr.store(newObjSize, sizeOffset);                        // Do not increment offset here, because there may be                        // another next free object, which we will combine                        // in the next loop.                    } else {                        offset = nextOffset;                    }                } else {                    offset = nextOffset;                }            }            // Set the address of the next free block, to the first free block            this.nextFreePtr = firstFreePtr;        } finally {            unlock();        }    }