anchor.diff:      }
       return count;
     }
  +  int _bitIndexToElementIndex(int bitIndex) {
  +    if (_bitsPerElement == 64) {
  +      return bitIndex >> 6;
  +    } else if (_bitsPerElement == 32) {
  +      return bitIndex >> 5;
  +    } else if (_bitsPerElement == 16) {
  +      return bitIndex >> 4;
  +    } else if (_bitsPerElement == 8) {
  +      return bitIndex >> 3;
  +    }
  +    assert(false);
  +    return 0;
  +  }
  +  int _bitIndexToElementBitIndex(int bitIndex) {
  +    return bitIndex & _elementBitIndexMask;
  +  }
     void setBit(int index) {
       if (index < 0) {
         throw new RangeError("Index ($index) must be greater than or equal to 0.");
       }
  -    int elementIndex = (index / _bitsPerElement).floor();
  +    int elementIndex = _bitIndexToElementIndex(index);
       if (elementIndex >= _elements.length) {
         _ensureCapacity(elementIndex + 1);
       }
  -    _elements[elementIndex] |= (1 << (index % _bitsPerElement));
  +    _elements[elementIndex] |= 1 << _bitIndexToElementBitIndex(index);
       _usedElements = max(_usedElements, elementIndex + 1);
     }
     void clearBit(int index) {
       if (index < 0) {
         throw new RangeError("Index ($index) must be greater than or equal to 0.");
       }
  -    int elementIndex = (index / _bitsPerElement).floor();
  +    int elementIndex = _bitIndexToElementIndex(index);
       if (elementIndex >= _elements.length) {
         return;
       }
  -    _elements[elementIndex] &= ~(1 << (index % _bitsPerElement));
  +    _elements[elementIndex] &= ~(1 << _bitIndexToElementBitIndex(index));
       _shrinkSize();
     }
     void flipBit(int index) {
       if (index < 0) {
         throw new RangeError("Index ($index) must be greater than or equal to 0.");
       }
  -    int elementIndex = (index / _bitsPerElement).floor();
  +    int elementIndex = _bitIndexToElementIndex(index);
       if (elementIndex >= _elements.length) {
         _ensureCapacity(elementIndex + 1);
       }
  -    _elements[elementIndex] ^= (1 << (index % _bitsPerElement));
  +    _elements[elementIndex] ^= (1 << _bitIndexToElementBitIndex(index));
       _usedElements = max(_usedElements, elementIndex + 1);
       _shrinkSize();
     }
  
positive.code:     }
      return bitSet;
    }
    List<int> _arrayForBits(int bitCount) {
      int capacity = ((bitCount + _bitsPerElement - 1)/ _bitsPerElement).floor();
      if (_bitsPerElement == 64) {
  
negative.code:     }
      _elements = _arrayForBits(bitCount);
      _bitsPerElement = (_elements as TypedData).elementSizeInBytes * 8;
      _elementBitIndexMask = _createElementBitIndexMask();
      _usedElements = 0;
    }
    factory VariableLengthBitSet.fromBitSet(BitSet bitSet) {
  