docs: protected Object addOrRemove(long longKey, long longValue,
                                   Object objectKey, Object objectValue,
                                   boolean remove) {
  
          int hash = (int) longKey;
  
          if (isObjectKey) {
              if (objectKey == null) {
                  return null;
              }
  
              hash = objectKey.hashCode();
          }
  
          int    index       = hashIndex.getHashIndex(hash);
          int    lookup      = hashIndex.hashTable[index];
          int    lastLookup  = -1;
          Object returnValue = null;
  
          for (; lookup >= 0;
                  lastLookup = lookup,
                  lookup = hashIndex.getNextLookup(lookup)) {
              if (isObjectKey) {
                  // A VoltDB extension to prevent an intermittent NPE on catalogUpdate?
                  if (objectKey.equals(objectKeyTable[lookup])) {
                  /* disabled 1 line ...
                  if (objectKeyTable[lookup].equals(objectKey)) {
                  ... disabled 1 line */
                  // End of VoltDB extension
                      break;
                  }
              } else if (isIntKey) {
                  if (longKey == intKeyTable[lookup]) {
                      break;
                  }
              } else if (isLongKey) {
                  if (longKey == longKeyTable[lookup]) {
                      break;
                  }
              }
          }
  
          if (lookup >= 0) {
              if (remove) {
                  if (isObjectKey) {
                      objectKeyTable[lookup] = null;
                  } else {
                      if (longKey == 0) {
                          hasZeroKey   = false;
                          zeroKeyIndex = -1;
                      }
  
                      if (isIntKey) {
                          intKeyTable[lookup] = 0;
                      } else {
                          longKeyTable[lookup] = 0;
                      }
                  }
  
                  if (isObjectValue) {
                      returnValue              = objectValueTable[lookup];
                      objectValueTable[lookup] = null;
                  } else if (isIntValue) {
                      intValueTable[lookup] = 0;
                  } else if (isLongValue) {
                      longValueTable[lookup] = 0;
                  }
  
                  hashIndex.unlinkNode(index, lastLookup, lookup);
  
                  if (accessTable != null) {
                      accessTable[lookup] = 0;
                  }
  
                  if (minimizeOnEmpty && hashIndex.elementCount == 0) {
                      rehash(initialCapacity);
                  }
  
                  return returnValue;
              }
  
              if (isObjectValue) {
                  returnValue              = objectValueTable[lookup];
                  objectValueTable[lookup] = objectValue;
              } else if (isIntValue) {
                  intValueTable[lookup] = (int) longValue;
              } else if (isLongValue) {
                  longValueTable[lookup] = longValue;
              }
  
              if (accessTable != null) {
                  accessTable[lookup] = accessCount++;
              }
  
              return returnValue;
          }
  
          // not found
          if (remove) {
              return null;
          }
  
          if (hashIndex.elementCount >= threshold) {
  
              // should throw maybe, if reset returns false?
              if (reset()) {
                  return addOrRemove(longKey, longValue, objectKey, objectValue,
                                     remove);
              } else {
                  return null;
              }
          }
  
          lookup = hashIndex.linkNode(index, lastLookup);
  
          // type dependent block
          if (isObjectKey) {
              objectKeyTable[lookup] = objectKey;
          } else if (isIntKey) {
              intKeyTable[lookup] = (int) longKey;
  
              if (longKey == 0) {
                  hasZeroKey   = true;
                  zeroKeyIndex = lookup;
              }
          } else if (isLongKey) {
              longKeyTable[lookup] = longKey;
  
              if (longKey == 0) {
                  hasZeroKey   = true;
                  zeroKeyIndex = lookup;
              }
          }
  
          if (isObjectValue) {
              objectValueTable[lookup] = objectValue;
          } else if (isIntValue) {
              intValueTable[lookup] = (int) longValue;
          } else if (isLongValue) {
              longValueTable[lookup] = longValue;
          }
  
          //
          if (accessTable != null) {
              accessTable[lookup] = accessCount++;
          }
  
          return returnValue;
      }