@edu.umd.cs.findbugs.annotations.SuppressWarnings(
      value = "QBA_QUESTIONABLE_BOOLEAN_ASSIGNMENT",
      justification = "Assignment designed to work this way.")
  private ReturnCode navigate(
      final byte[] currentKey, int offset, int length, Terminate terminate) {
    int nSlots = slots.size();
    // First check to see if we're in-range until we reach our end key
    if (endKeyLength > 0) {
      if (Bytes.compareTo(currentKey, offset, length, endKey, 0, endKeyLength) < 0) {
        return ReturnCode.INCLUDE;
      }

      // If key range of last slot is a single key, we can increment our position
      // since we know we'll be past the current row after including it.
      if (slots.get(nSlots - 1).get(position[nSlots - 1]).isSingleKey()) {
        if (nextPosition(nSlots - 1) < 0) {
          // Current row will be included, but we have no more
          isDone = true;
          return ReturnCode.NEXT_ROW;
        }
      } else {
        // Reset the positions to zero from the next slot after the earliest ranged slot, since the
        // next key could be bigger at this ranged slot, and smaller than the current position of
        // less significant slots.
        int earliestRangeIndex = nSlots - 1;
        for (int i = 0; i < nSlots; i++) {
          if (!slots.get(i).get(position[i]).isSingleKey()) {
            earliestRangeIndex = i;
            break;
          }
        }
        Arrays.fill(position, earliestRangeIndex + 1, position.length, 0);
      }
    }
    endKeyLength = 0;

    // We could have included the previous
    if (isDone) {
      return ReturnCode.NEXT_ROW;
    }

    int i = 0;
    boolean seek = false;
    int earliestRangeIndex = nSlots - 1;
    ptr.set(currentKey, offset, length);
    schema.first(ptr, i, ValueBitSet.EMPTY_VALUE_BITSET);
    while (true) {
      // Increment to the next range while the upper bound of our current slot is less than our
      // current key
      while (position[i] < slots.get(i).size()
          && slots.get(i).get(position[i]).compareUpperToLowerBound(ptr) < 0) {
        position[i]++;
      }
      Arrays.fill(position, i + 1, position.length, 0);
      if (position[i] >= slots.get(i).size()) {
        // Our current key is bigger than the last range of the current slot.
        // If navigating after current key, backtrack and increment the key of the previous slot
        // values.
        // If navigating to current key, just return
        if (terminate == Terminate.AT) {
          return ReturnCode.SEEK_NEXT_USING_HINT;
        }
        if (i == 0) {
          isDone = true;
          return ReturnCode.NEXT_ROW;
        }
        // Increment key and backtrack until in range. We know at this point that we'll be
        // issuing a seek next hint.
        seek = true;
        Arrays.fill(position, i, position.length, 0);
        i--;
        // If we're positioned at a single key, no need to copy the current key and get the next key
        // .
        // Instead, just increment to the next key and continue.
        boolean incremented = false;
        while (i >= 0
            && slots.get(i).get(position[i]).isSingleKey()
            && (incremented = true)
            && (position[i] = (position[i] + 1) % slots.get(i).size()) == 0) {
          i--;
          incremented = false;
        }
        if (i < 0) {
          isDone = true;
          return ReturnCode.NEXT_ROW;
        }
        if (incremented) {
          // Continue the loop after setting the start key, because our start key maybe smaller than
          // the current key, so we'll end up incrementing the start key until it's bigger than the
          // current key.
          setStartKey();
          ptr.set(ptr.get(), offset, length);
          // Reinitialize iterator to be positioned at previous slot position
          schema.setAccessor(ptr, i, ValueBitSet.EMPTY_VALUE_BITSET);
        } else {
          int currentLength = setStartKey(ptr, offset, i + 1);
          // From here on, we use startKey as our buffer with offset reset to 0
          // We've copied the part of the current key above that we need into startKey
          ptr.set(startKey, offset = 0, length = startKeyLength);
          // Reinitialize iterator to be positioned at previous slot position
          // TODO: a schema.previous would potentially be more efficient
          schema.setAccessor(ptr, i, ValueBitSet.EMPTY_VALUE_BITSET);
          // Do nextKey after setting the accessor b/c otherwise the null byte may have
          // been incremented causing us not to find it
          ByteUtil.nextKey(startKey, currentLength);
        }
      } else if (slots.get(i).get(position[i]).compareLowerToUpperBound(ptr) > 0) {
        // Our current key is less than the lower range of the current position in the current slot.
        // Seek to the lower range, since it's bigger than the current key
        setStartKey(ptr, offset, i);
        return ReturnCode.SEEK_NEXT_USING_HINT;
      } else { // We're in range, check the next slot
        if (!slots.get(i).get(position[i]).isSingleKey() && i < earliestRangeIndex) {
          earliestRangeIndex = i;
        }
        i++;
        // If we're past the last slot or we know we're seeking to the next (in
        // which case the previously updated slot was verified to be within the
        // range, so we don't need to check the rest of the slots. If we were
        // to check the rest of the slots, we'd get into trouble because we may
        // have a null byte that was incremented which screws up our schema.next call)
        if (i >= nSlots || seek) {
          break;
        }
        // If we run out of slots in our key, it means we have a partial key. In this
        // case, we seek to the next full key after this one.
        // TODO: test for this
        if (schema.next(ptr, i, offset + length, ValueBitSet.EMPTY_VALUE_BITSET) == null) {
          setStartKey(ptr, offset, i);
          return ReturnCode.SEEK_NEXT_USING_HINT;
        }
      }
    }

    if (seek) {
      return ReturnCode.SEEK_NEXT_USING_HINT;
    }
    // Else, we're in range for all slots and can include this row plus all rows
    // up to the upper range of our last slot. We do this for ranges and single keys
    // since we potentially have multiple key values for the same row key.
    setEndKey(ptr, offset, slots.size() - 1);
    return ReturnCode.INCLUDE;
  }
 private boolean intersect(
     byte[] lowerInclusiveKey, byte[] upperExclusiveKey, List<List<KeyRange>> newSlots) {
   boolean lowerUnbound = (lowerInclusiveKey.length == 0);
   Arrays.fill(position, 0);
   isDone = false;
   int startPos = 0;
   int lastSlot = slots.size() - 1;
   if (!lowerUnbound) {
     // Find the position of the first slot of the lower range
     ptr.set(lowerInclusiveKey);
     schema.first(ptr, 0, ValueBitSet.EMPTY_VALUE_BITSET);
     startPos = ScanUtil.searchClosestKeyRangeWithUpperHigherThanPtr(slots.get(0), ptr, 0);
     // Lower range is past last upper range of first slot, so cannot possibly be in range
     if (startPos >= slots.get(0).size()) {
       return false;
     }
   }
   boolean upperUnbound = (upperExclusiveKey.length == 0);
   int endPos = slots.get(0).size() - 1;
   if (!upperUnbound) {
     // Find the position of the first slot of the upper range
     ptr.set(upperExclusiveKey);
     schema.first(ptr, 0, ValueBitSet.EMPTY_VALUE_BITSET);
     endPos = ScanUtil.searchClosestKeyRangeWithUpperHigherThanPtr(slots.get(0), ptr, startPos);
     // Upper range lower than first lower range of first slot, so cannot possibly be in range
     if (endPos == 0
         && Bytes.compareTo(upperExclusiveKey, slots.get(0).get(0).getLowerRange()) <= 0) {
       return false;
     }
     // Past last position, so we can include everything from the start position
     if (endPos >= slots.get(0).size()) {
       upperUnbound = true;
       endPos = slots.get(0).size() - 1;
     }
   }
   if (!lowerUnbound) {
     position[0] = startPos;
     navigate(lowerInclusiveKey, 0, lowerInclusiveKey.length, Terminate.AFTER);
     if (filterAllRemaining()) {
       return false;
     }
   }
   if (upperUnbound) {
     if (newSlots != null) {
       newSlots.add(slots.get(0).subList(startPos, endPos + 1));
       newSlots.addAll(slots.subList(1, slots.size()));
     }
     return true;
   }
   int[] lowerPosition = Arrays.copyOf(position, position.length);
   // Navigate to the upperExclusiveKey, but not past it
   ReturnCode endCode = navigate(upperExclusiveKey, 0, upperExclusiveKey.length, Terminate.AT);
   if (endCode == ReturnCode.INCLUDE) {
     setStartKey();
     // If the upperExclusiveKey is equal to the start key, we've gone one position too far, since
     // our upper key is exclusive. In that case, go to the previous key
     if (Bytes.compareTo(
                 startKey, 0, startKeyLength, upperExclusiveKey, 0, upperExclusiveKey.length)
             == 0
         && (previousPosition(lastSlot) < 0 || position[0] < lowerPosition[0])) {
       // If by backing up one position we have an empty range, then return
       return false;
     }
   } else if (endCode == ReturnCode.SEEK_NEXT_USING_HINT) {
     // The upperExclusive key is smaller than the slots stored in the position. Check if it's the
     // same position
     // as the slots for lowerInclusive. If so, there is no intersection.
     if (Arrays.equals(lowerPosition, position)) {
       return false;
     }
   }
   // Copy inclusive all positions
   for (int i = 0; i <= lastSlot; i++) {
     List<KeyRange> newRanges =
         slots.get(i).subList(lowerPosition[i], Math.min(position[i] + 1, slots.get(i).size()));
     if (newRanges.isEmpty()) {
       return false;
     }
     if (newSlots != null) {
       newSlots.add(newRanges);
     }
     if (position[i] > lowerPosition[i]) {
       if (newSlots != null) {
         newSlots.addAll(slots.subList(i + 1, slots.size()));
       }
       break;
     }
   }
   return true;
 }