docs: public boolean add(int e)
    {
  
      // range check
      if (e < ConciseSetUtils.MIN_ALLOWED_SET_BIT || e > ConciseSetUtils.MAX_ALLOWED_INTEGER) {
        throw new IndexOutOfBoundsException(String.valueOf(e));
      }
  
      // the element can be simply appended
      if (e > last) {
        append(e);
        return true;
      }
  
      if (e == last) {
        return false;
      }
  
      // check if the element can be put in a literal word
      int blockIndex = maxLiteralLengthDivision(e);
      int bitPosition = maxLiteralLengthModulus(e);
      for (int i = 0; i <= lastWordIndex && blockIndex >= 0; i++) {
        int w = words[i];
        if (isLiteral(w)) {
          // check if the current literal word is the "right" one
          if (blockIndex == 0) {
            // bit already set
            if ((w & (1 << bitPosition)) != 0) {
              return false;
            }
  
            // By adding the bit we potentially create a sequence:
            // -- If the literal is made up of all zeros, it definitely
            //    cannot be part of a sequence (otherwise it would not have
            //    been created). Thus, we can create a 1-bit literal word
            // -- If there are MAX_LITERAL_LENGTH - 2 set bits, by adding
            //    the new one we potentially allow for a 1's sequence
            //    together with the successive word
            // -- If there are MAX_LITERAL_LENGTH - 1 set bits, by adding
            //    the new one we potentially allow for a 1's sequence
            //    together with the successive and/or the preceding words
            if (!simulateWAH) {
              int bitCount = getLiteralBitCount(w);
              if (bitCount >= ConciseSetUtils.MAX_LITERAL_LENGTH - 2) {
                break;
              }
            } else {
              if (containsOnlyOneBit(~w) || w == ConciseSetUtils.ALL_ONES_LITERAL) {
                break;
              }
            }
  
            // set the bit
            words[i] |= 1 << bitPosition;
            if (size >= 0) {
              size++;
            }
            return true;
          }
  
          blockIndex--;
        } else {
          if (simulateWAH) {
            if (isOneSequence(w) && blockIndex <= getSequenceCount(w)) {
              return false;
            }
          } else {
            // if we are at the beginning of a sequence, and it is
            // a set bit, the bit already exists
            if (blockIndex == 0
                && (getLiteral(w) & (1 << bitPosition)) != 0) {
              return false;
            }
  
            // if we are in the middle of a sequence of 1's, the bit already exist
            if (blockIndex > 0
                && blockIndex <= getSequenceCount(w)
                && isOneSequence(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 add it is by ORing
      return replaceWith(performOperation(convert(e), Operator.OR));
    }