code: private boolean trySwapVictimIntoEmptySpot() {
  
  		long curIndex = victim.getI2();
  		// lock bucket. We always use I2 since victim tag is from bucket I1
  		bucketLocker.lockSingleBucketWrite(curIndex);
  		long curTag = table.swapRandomTagInBucket(curIndex, victim.getTag());
  		bucketLocker.unlockSingleBucketWrite(curIndex);
  		// new victim's I2 is different as long as tag isn't the same
  		long altIndex = hasher.altIndex(curIndex, curTag);
  		// try to insert the new victim tag in it's alternate bucket
  		bucketLocker.lockSingleBucketWrite(altIndex);
  		try {
  			if (table.insertToBucket(altIndex, curTag)) {
  				hasVictim = false;
  				return true;
  			} else {
  				// still have a victim, but a different one...
  				victim.setTag(curTag);
  				// new victim always shares I1 with previous victims' I2
  				victim.setI1(curIndex);
  				victim.setI2(altIndex);
  			}
  		} finally {
  			bucketLocker.unlockSingleBucketWrite(altIndex);
  		}
  		return false;
  
  	}
docs: if we kicked a tag we need to move it to alternate position, possibly
  kicking another tag there, repeating the process until we succeed or run
  out of chances
  
  The basic flow below is to insert our current tag into a position in an
  already full bucket, then move the tag that we overwrote to it's
  alternate index. We repeat this until we move a tag into a non-full
  bucket or run out of attempts. This tag shuffling process is what gives
  the Cuckoo filter such a high load factor. When we run out of attempts,
  we leave the orphaned tag in the victim slot.
  
  We need to be extremely careful here to avoid deadlocks and thread stalls
  during this process. The most nefarious deadlock is that two or more
  threads run out of tries simultaneously and all need a place to store a
  victim even though we only have one slot