code: protected void shiftConflictingKeys(int gapSlot) {
      final KType[] keys = Intrinsics.<KType[]> cast(this.keys);
      final VType[] values = Intrinsics.<VType[]> cast(this.values);
      final int mask = this.mask;
  
      // Perform shifts of conflicting keys to fill in the gap.
      int distance = 0;
      while (true) {
        final int slot = (gapSlot + (++distance)) & mask;
        final KType existing = keys[slot];
        if (Intrinsics.<KType> isEmpty(existing)) {
          break;
        }
  
        final int idealSlot = hashKey(existing);
        final int shift = (slot - idealSlot) & mask;
        if (shift >= distance) {
          // Entry at this position was originally at or before the gap slot.
          // Move the conflict-shifted entry to the gap's position and repeat the procedure
          // for any entries to the right of the current position, treating it
          // as the new gap.
          keys[gapSlot] = existing;
          values[gapSlot] = values[slot]; 
          gapSlot = slot;
          distance = 0;
        }
      }
  
      // Mark the last found gap slot without a conflict as empty.
      keys[gapSlot] = Intrinsics.<KType> empty();
      values[gapSlot] = Intrinsics.<VType> empty();
      assigned--;
    }
docs: Shift all the slot-conflicting keys and values allocated to
  (and including) <code>slot</code>.