MiniEnumSet(Class<E> elementType) 
{
        super(elementType);
        enums = elementType.getEnumConstants();
}

 public boolean add(E element) 
{
        if (!isValidType(element.getDeclaringClass())) {
            throw new ClassCastException();
        }
        long oldBits = bits;
        long newBits = oldBits | (1L < <  element.ordinal());
        if (oldBits != newBits) {
            bits = newBits;
            size++;
            return true;
        }
        return false;
}

 public boolean addAll(Collection<? extends E> collection) 
{
        if (collection.isEmpty()) {
            return false;
        }
        if (collection instanceof EnumSet) {
            EnumSet< ? > set = (EnumSet< ? >) collection;
            if (!isValidType(set.elementClass)) {
                throw new ClassCastException();
            }
            MiniEnumSet< ? > miniSet = (MiniEnumSet< ? >) set;
            long oldBits = bits;
            long newBits = oldBits | miniSet.bits;
            bits = newBits;
            size = Long.bitCount(newBits);
            return (oldBits != newBits);
        }
        return super.addAll(collection);
}

 public  void clear() 
{
        bits = 0;
        size = 0;
}

  void complement() 
{
        if (enums.length != 0) {
            bits = ~bits;
            bits &= (-1L  > > > (MAX_ELEMENTS - enums.length));
            size = enums.length - size;
        }
}

 public boolean contains(Object object) 
{
        if (object == null || !isValidType(object.getClass())) {
            return false;
        }
        @SuppressWarnings("unchecked") // guarded by isValidType()
        Enum< E > element = (Enum< E >) object;
        int ordinal = element.ordinal();
        return (bits & (1L < <  ordinal)) != 0;
}

 public boolean containsAll(Collection<?> collection) 
{
        if (collection.isEmpty()) {
            return true;
        }
        if (collection instanceof MiniEnumSet) {
            MiniEnumSet< ? > set = (MiniEnumSet< ? >) collection;
            long setBits = set.bits;
            return isValidType(set.elementClass) && ((bits & setBits) == setBits);
        }
        return !(collection instanceof EnumSet) && super.containsAll(collection);
}

 public boolean equals(Object object) 
{
        if (!(object instanceof EnumSet)) {
            return super.equals(object);
        }
        EnumSet< ? > set =(EnumSet< ? >) object;
        if (!isValidType(set.elementClass)) {
            return size == 0 && set.isEmpty();
        }
        return bits == ((MiniEnumSet< ? >) set).bits;
}

 public Iterator<E> iterator() 
{
        return new MiniEnumSetIterator();
}

 public boolean remove(Object object) 
{
        if (object == null || !isValidType(object.getClass())) {
            return false;
        }
        @SuppressWarnings("unchecked") // guarded by isValidType() 
        Enum< E > element = (Enum< E >) object;
        int ordinal = element.ordinal();
        long oldBits = bits;
        long newBits = oldBits & ~(1L < <  ordinal);
        if (oldBits != newBits) {
            bits = newBits;
            size--;
            return true;
        }
        return false;
}

 public boolean removeAll(Collection<?> collection) 
{
        if (collection.isEmpty()) {
            return false;
        }
        if (collection instanceof EnumSet) {
            EnumSet< ? > set = (EnumSet< ? >) collection;
            if (!isValidType(set.elementClass)) {
                return false;
            }
            MiniEnumSet< E > miniSet = (MiniEnumSet< E >) set;
            long oldBits = bits;
            long newBits = oldBits & ~miniSet.bits;
            if (oldBits != newBits) {
                bits = newBits;
                size = Long.bitCount(newBits);
                return true;
            }
            return false;
        }
        return super.removeAll(collection);
}

 public boolean retainAll(Collection<?> collection) 
{
        if (collection instanceof EnumSet) {
            EnumSet< ? > set = (EnumSet< ? >) collection;
            if (!isValidType(set.elementClass)) {
                if (size  > 0) {
                    clear();
                    return true;
                } else {
                    return false;
                }
            }
            MiniEnumSet< E > miniSet = (MiniEnumSet< E >) set;
            long oldBits = bits;
            long newBits = oldBits & miniSet.bits;
            if (oldBits != newBits) {
                bits = newBits;
                size = Long.bitCount(newBits);
                return true;
            }
            return false;
        }
        return super.retainAll(collection);
}

  void setRange(E start,
    E end) 
{
        int length = end.ordinal() - start.ordinal() + 1;
        long range = (-1L  > > > (MAX_ELEMENTS - length)) < <  start.ordinal();
        bits |= range;
        size = Long.bitCount(bits);
}

 public int size() 
{
        return size;
}