docs: public boolean remove(int o)
    {
  
      if (isEmpty()) {
        return false;
      }
  
      // the element cannot exist
      if (o > last) {
        return false;
      }
  
      // check if the element can be removed from a literal word
      int blockIndex = maxLiteralLengthDivision(o);
      int bitPosition = maxLiteralLengthModulus(o);
      for (int i = 0; i <= lastWordIndex && blockIndex >= 0; i++) {
        final int w = words[i];
        if (isLiteral(w)) {
          // check if the current literal word is the "right" one
          if (blockIndex == 0) {
            // the bit is already unset
            if ((w & (1 << bitPosition)) == 0) {
              return false;
            }
  
            // By removing the bit we potentially create a sequence:
            // -- If the literal is made up of all ones, it definitely
            //    cannot be part of a sequence (otherwise it would not have
            //    been created). Thus, we can create a 30-bit literal word
            // -- If there are 2 set bits, by removing the specified
            //    one we potentially allow for a 1's sequence together with
            //    the successive word
            // -- If there is 1 set bit, by removing the new one we
            //    potentially allow for a 0's sequence
            //    together with the successive and/or the preceding words
            if (!simulateWAH) {
              int bitCount = getLiteralBitCount(w);
              if (bitCount <= 2) {
                break;
              }
            } else {
              final int l = getLiteralBits(w);
              if (l == 0 || containsOnlyOneBit(l)) {
                break;
              }
            }
  
            // unset the bit
            words[i] &= ~(1 << bitPosition);
            if (size >= 0) {
              size--;
            }
  
            // if the bit is the maximal element, update it
            if (o == last) {
              last -= maxLiteralLengthModulus(last) - (ConciseSetUtils.MAX_LITERAL_LENGTH
                                                       - Integer.numberOfLeadingZeros(getLiteralBits(words[i])));
            }
            return true;
          }
  
          blockIndex--;
        } else {
          if (simulateWAH) {
            if (isZeroSequence(w) && blockIndex <= getSequenceCount(w)) {
              return false;
            }
          } else {
            // if we are at the beginning of a sequence, and it is
            // an unset bit, the bit does not exist
            if (blockIndex == 0
                && (getLiteral(w) & (1 << bitPosition)) == 0) {
              return false;
            }
  
            // if we are in the middle of a sequence of 0's, the bit does not exist
            if (blockIndex > 0
                && blockIndex <= getSequenceCount(w)
                && isZeroSequence(w)) {
              return false;
            }
          }
  
          // next word
          blockIndex -= getSequenceCount(w) + 1;
        }
      }
  
      // the bit is in the middle of a sequence or it may cause a literal to
      // become a sequence, thus the "easiest" way to remove it by ANDNOTing
      return replaceWith(performOperation(convert(o), Operator.ANDNOT));
    }