CrackMe.apk
Download file
package com.google.common.collect;
import com.google.common.base.Preconditions;
import com.google.common.base.Predicate;
import com.google.common.base.Predicates;
import com.google.common.collect.Collections2;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.math.IntMath;
import java.io.Serializable;
import java.util.AbstractSet;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.NavigableSet;
import java.util.NoSuchElementException;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArraySet;
import javax.annotation.CheckForNull;
@ElementTypesAreNonnullByDefault
public final class Sets {
private Sets() {
}
static abstract class ImprovedAbstractSet<E> extends AbstractSet<E> {
ImprovedAbstractSet() {
}
public boolean removeAll(Collection<?> collection) {
return Sets.removeAllImpl((Set<?>) this, collection);
}
public boolean retainAll(Collection<?> collection) {
return super.retainAll((Collection) Preconditions.checkNotNull(collection));
}
}
public static <E extends Enum<E>> ImmutableSet<E> immutableEnumSet(E e, E... eArr) {
return ImmutableEnumSet.asImmutable(EnumSet.of(e, eArr));
}
public static <E extends Enum<E>> ImmutableSet<E> immutableEnumSet(Iterable<E> iterable) {
if (iterable instanceof ImmutableEnumSet) {
return (ImmutableEnumSet) iterable;
}
if (iterable instanceof Collection) {
Collection collection = (Collection) iterable;
if (collection.isEmpty()) {
return ImmutableSet.of();
}
return ImmutableEnumSet.asImmutable(EnumSet.copyOf(collection));
}
Iterator<E> it = iterable.iterator();
if (!it.hasNext()) {
return ImmutableSet.of();
}
EnumSet of = EnumSet.of((Enum) it.next());
Iterators.addAll(of, it);
return ImmutableEnumSet.asImmutable(of);
}
public static <E extends Enum<E>> EnumSet<E> newEnumSet(Iterable<E> iterable, Class<E> cls) {
EnumSet<E> noneOf = EnumSet.noneOf(cls);
Iterables.addAll(noneOf, iterable);
return noneOf;
}
public static <E> HashSet<E> newHashSet() {
return new HashSet<>();
}
public static <E> HashSet<E> newHashSet(E... eArr) {
HashSet<E> newHashSetWithExpectedSize = newHashSetWithExpectedSize(eArr.length);
Collections.addAll(newHashSetWithExpectedSize, eArr);
return newHashSetWithExpectedSize;
}
public static <E> HashSet<E> newHashSet(Iterable<? extends E> iterable) {
if (iterable instanceof Collection) {
return new HashSet<>((Collection) iterable);
}
return newHashSet(iterable.iterator());
}
public static <E> HashSet<E> newHashSet(Iterator<? extends E> it) {
HashSet<E> newHashSet = newHashSet();
Iterators.addAll(newHashSet, it);
return newHashSet;
}
public static <E> HashSet<E> newHashSetWithExpectedSize(int i) {
return new HashSet<>(Maps.capacity(i));
}
public static <E> Set<E> newConcurrentHashSet() {
return Collections.newSetFromMap(new ConcurrentHashMap());
}
public static <E> Set<E> newConcurrentHashSet(Iterable<? extends E> iterable) {
Set<E> newConcurrentHashSet = newConcurrentHashSet();
Iterables.addAll(newConcurrentHashSet, iterable);
return newConcurrentHashSet;
}
public static <E> LinkedHashSet<E> newLinkedHashSet() {
return new LinkedHashSet<>();
}
public static <E> LinkedHashSet<E> newLinkedHashSet(Iterable<? extends E> iterable) {
if (iterable instanceof Collection) {
return new LinkedHashSet<>((Collection) iterable);
}
LinkedHashSet<E> newLinkedHashSet = newLinkedHashSet();
Iterables.addAll(newLinkedHashSet, iterable);
return newLinkedHashSet;
}
public static <E> LinkedHashSet<E> newLinkedHashSetWithExpectedSize(int i) {
return new LinkedHashSet<>(Maps.capacity(i));
}
public static <E extends Comparable> TreeSet<E> newTreeSet() {
return new TreeSet<>();
}
public static <E extends Comparable> TreeSet<E> newTreeSet(Iterable<? extends E> iterable) {
TreeSet<E> newTreeSet = newTreeSet();
Iterables.addAll(newTreeSet, iterable);
return newTreeSet;
}
public static <E> TreeSet<E> newTreeSet(Comparator<? super E> comparator) {
return new TreeSet<>((Comparator) Preconditions.checkNotNull(comparator));
}
public static <E> Set<E> newIdentityHashSet() {
return Collections.newSetFromMap(Maps.newIdentityHashMap());
}
public static <E> CopyOnWriteArraySet<E> newCopyOnWriteArraySet() {
return new CopyOnWriteArraySet<>();
}
/* JADX WARNING: type inference failed for: r1v0, types: [java.lang.Iterable<? extends E>, java.lang.Iterable] */
/* JADX WARNING: Unknown variable types count: 1 */
/* Code decompiled incorrectly, please refer to instructions dump. */
public static <E> java.util.concurrent.CopyOnWriteArraySet<E> newCopyOnWriteArraySet(java.lang.Iterable<? extends E> r1) {
/*
boolean r0 = r1 instanceof java.util.Collection
if (r0 == 0) goto L_0x0007
java.util.Collection r1 = (java.util.Collection) r1
goto L_0x000b
L_0x0007:
java.util.ArrayList r1 = com.google.common.collect.Lists.newArrayList(r1)
L_0x000b:
java.util.concurrent.CopyOnWriteArraySet r0 = new java.util.concurrent.CopyOnWriteArraySet
r0.<init>(r1)
return r0
*/
throw new UnsupportedOperationException("Method not decompiled: com.google.common.collect.Sets.newCopyOnWriteArraySet(java.lang.Iterable):java.util.concurrent.CopyOnWriteArraySet");
}
public static <E extends Enum<E>> EnumSet<E> complementOf(Collection<E> collection) {
if (collection instanceof EnumSet) {
return EnumSet.complementOf((EnumSet) collection);
}
Preconditions.checkArgument(!collection.isEmpty(), "collection is empty; use the other version of this method");
return makeComplementByHand(collection, ((Enum) collection.iterator().next()).getDeclaringClass());
}
public static <E extends Enum<E>> EnumSet<E> complementOf(Collection<E> collection, Class<E> cls) {
Preconditions.checkNotNull(collection);
if (collection instanceof EnumSet) {
return EnumSet.complementOf((EnumSet) collection);
}
return makeComplementByHand(collection, cls);
}
private static <E extends Enum<E>> EnumSet<E> makeComplementByHand(Collection<E> collection, Class<E> cls) {
EnumSet<E> allOf = EnumSet.allOf(cls);
allOf.removeAll(collection);
return allOf;
}
@Deprecated
public static <E> Set<E> newSetFromMap(Map<E, Boolean> map) {
return Collections.newSetFromMap(map);
}
public static abstract class SetView<E> extends AbstractSet<E> {
public abstract UnmodifiableIterator<E> iterator();
private SetView() {
}
public ImmutableSet<E> immutableCopy() {
return ImmutableSet.copyOf(this);
}
public <S extends Set<E>> S copyInto(S s) {
s.addAll(this);
return s;
}
@Deprecated
public final boolean add(@ParametricNullness E e) {
throw new UnsupportedOperationException();
}
@Deprecated
public final boolean remove(@CheckForNull Object obj) {
throw new UnsupportedOperationException();
}
@Deprecated
public final boolean addAll(Collection<? extends E> collection) {
throw new UnsupportedOperationException();
}
@Deprecated
public final boolean removeAll(Collection<?> collection) {
throw new UnsupportedOperationException();
}
@Deprecated
public final boolean retainAll(Collection<?> collection) {
throw new UnsupportedOperationException();
}
@Deprecated
public final void clear() {
throw new UnsupportedOperationException();
}
}
public static <E> SetView<E> union(final Set<? extends E> set, final Set<? extends E> set2) {
Preconditions.checkNotNull(set, "set1");
Preconditions.checkNotNull(set2, "set2");
return new SetView<E>() {
public int size() {
int size = set.size();
for (Object contains : set2) {
if (!set.contains(contains)) {
size++;
}
}
return size;
}
public boolean isEmpty() {
return set.isEmpty() && set2.isEmpty();
}
public UnmodifiableIterator<E> iterator() {
return new AbstractIterator<E>() {
final Iterator<? extends E> itr1;
final Iterator<? extends E> itr2;
{
this.itr1 = set.iterator();
this.itr2 = set2.iterator();
}
/* access modifiers changed from: protected */
@CheckForNull
public E computeNext() {
if (this.itr1.hasNext()) {
return this.itr1.next();
}
while (this.itr2.hasNext()) {
E next = this.itr2.next();
if (!set.contains(next)) {
return next;
}
}
return endOfData();
}
};
}
public boolean contains(@CheckForNull Object obj) {
return set.contains(obj) || set2.contains(obj);
}
public <S extends Set<E>> S copyInto(S s) {
s.addAll(set);
s.addAll(set2);
return s;
}
public ImmutableSet<E> immutableCopy() {
return new ImmutableSet.Builder().addAll((Iterable) set).addAll((Iterable) set2).build();
}
};
}
public static <E> SetView<E> intersection(final Set<E> set, final Set<?> set2) {
Preconditions.checkNotNull(set, "set1");
Preconditions.checkNotNull(set2, "set2");
return new SetView<E>() {
public UnmodifiableIterator<E> iterator() {
return new AbstractIterator<E>() {
final Iterator<E> itr;
{
this.itr = set.iterator();
}
/* access modifiers changed from: protected */
@CheckForNull
public E computeNext() {
while (this.itr.hasNext()) {
E next = this.itr.next();
if (set2.contains(next)) {
return next;
}
}
return endOfData();
}
};
}
public int size() {
int i = 0;
for (Object contains : set) {
if (set2.contains(contains)) {
i++;
}
}
return i;
}
public boolean isEmpty() {
return Collections.disjoint(set2, set);
}
public boolean contains(@CheckForNull Object obj) {
return set.contains(obj) && set2.contains(obj);
}
public boolean containsAll(Collection<?> collection) {
return set.containsAll(collection) && set2.containsAll(collection);
}
};
}
public static <E> SetView<E> difference(final Set<E> set, final Set<?> set2) {
Preconditions.checkNotNull(set, "set1");
Preconditions.checkNotNull(set2, "set2");
return new SetView<E>() {
public UnmodifiableIterator<E> iterator() {
return new AbstractIterator<E>() {
final Iterator<E> itr;
{
this.itr = set.iterator();
}
/* access modifiers changed from: protected */
@CheckForNull
public E computeNext() {
while (this.itr.hasNext()) {
E next = this.itr.next();
if (!set2.contains(next)) {
return next;
}
}
return endOfData();
}
};
}
public int size() {
int i = 0;
for (Object contains : set) {
if (!set2.contains(contains)) {
i++;
}
}
return i;
}
public boolean isEmpty() {
return set2.containsAll(set);
}
public boolean contains(@CheckForNull Object obj) {
return set.contains(obj) && !set2.contains(obj);
}
};
}
public static <E> SetView<E> symmetricDifference(final Set<? extends E> set, final Set<? extends E> set2) {
Preconditions.checkNotNull(set, "set1");
Preconditions.checkNotNull(set2, "set2");
return new SetView<E>() {
public UnmodifiableIterator<E> iterator() {
final Iterator it = set.iterator();
final Iterator it2 = set2.iterator();
return new AbstractIterator<E>() {
@CheckForNull
public E computeNext() {
while (it.hasNext()) {
E next = it.next();
if (!set2.contains(next)) {
return next;
}
}
while (it2.hasNext()) {
E next2 = it2.next();
if (!set.contains(next2)) {
return next2;
}
}
return endOfData();
}
};
}
public int size() {
int i = 0;
for (Object contains : set) {
if (!set2.contains(contains)) {
i++;
}
}
for (Object contains2 : set2) {
if (!set.contains(contains2)) {
i++;
}
}
return i;
}
public boolean isEmpty() {
return set.equals(set2);
}
public boolean contains(@CheckForNull Object obj) {
return set2.contains(obj) ^ set.contains(obj);
}
};
}
public static <E> Set<E> filter(Set<E> set, Predicate<? super E> predicate) {
if (set instanceof SortedSet) {
return filter((SortedSet) set, predicate);
}
if (!(set instanceof FilteredSet)) {
return new FilteredSet((Set) Preconditions.checkNotNull(set), (Predicate) Preconditions.checkNotNull(predicate));
}
FilteredSet filteredSet = (FilteredSet) set;
return new FilteredSet((Set) filteredSet.unfiltered, Predicates.and(filteredSet.predicate, predicate));
}
public static <E> SortedSet<E> filter(SortedSet<E> sortedSet, Predicate<? super E> predicate) {
if (!(sortedSet instanceof FilteredSet)) {
return new FilteredSortedSet((SortedSet) Preconditions.checkNotNull(sortedSet), (Predicate) Preconditions.checkNotNull(predicate));
}
FilteredSet filteredSet = (FilteredSet) sortedSet;
return new FilteredSortedSet((SortedSet) filteredSet.unfiltered, Predicates.and(filteredSet.predicate, predicate));
}
public static <E> NavigableSet<E> filter(NavigableSet<E> navigableSet, Predicate<? super E> predicate) {
if (!(navigableSet instanceof FilteredSet)) {
return new FilteredNavigableSet((NavigableSet) Preconditions.checkNotNull(navigableSet), (Predicate) Preconditions.checkNotNull(predicate));
}
FilteredSet filteredSet = (FilteredSet) navigableSet;
return new FilteredNavigableSet((NavigableSet) filteredSet.unfiltered, Predicates.and(filteredSet.predicate, predicate));
}
private static class FilteredSet<E> extends Collections2.FilteredCollection<E> implements Set<E> {
FilteredSet(Set<E> set, Predicate<? super E> predicate) {
super(set, predicate);
}
public boolean equals(@CheckForNull Object obj) {
return Sets.equalsImpl(this, obj);
}
public int hashCode() {
return Sets.hashCodeImpl(this);
}
}
private static class FilteredSortedSet<E> extends FilteredSet<E> implements SortedSet<E> {
FilteredSortedSet(SortedSet<E> sortedSet, Predicate<? super E> predicate) {
super(sortedSet, predicate);
}
@CheckForNull
public Comparator<? super E> comparator() {
return ((SortedSet) this.unfiltered).comparator();
}
public SortedSet<E> subSet(@ParametricNullness E e, @ParametricNullness E e2) {
return new FilteredSortedSet(((SortedSet) this.unfiltered).subSet(e, e2), this.predicate);
}
public SortedSet<E> headSet(@ParametricNullness E e) {
return new FilteredSortedSet(((SortedSet) this.unfiltered).headSet(e), this.predicate);
}
public SortedSet<E> tailSet(@ParametricNullness E e) {
return new FilteredSortedSet(((SortedSet) this.unfiltered).tailSet(e), this.predicate);
}
@ParametricNullness
public E first() {
return Iterators.find(this.unfiltered.iterator(), this.predicate);
}
@ParametricNullness
public E last() {
SortedSet sortedSet = (SortedSet) this.unfiltered;
while (true) {
E last = sortedSet.last();
if (this.predicate.apply(last)) {
return last;
}
sortedSet = sortedSet.headSet(last);
}
}
}
private static class FilteredNavigableSet<E> extends FilteredSortedSet<E> implements NavigableSet<E> {
FilteredNavigableSet(NavigableSet<E> navigableSet, Predicate<? super E> predicate) {
super(navigableSet, predicate);
}
/* access modifiers changed from: package-private */
public NavigableSet<E> unfiltered() {
return (NavigableSet) this.unfiltered;
}
@CheckForNull
public E lower(@ParametricNullness E e) {
return Iterators.find(unfiltered().headSet(e, false).descendingIterator(), this.predicate, null);
}
@CheckForNull
public E floor(@ParametricNullness E e) {
return Iterators.find(unfiltered().headSet(e, true).descendingIterator(), this.predicate, null);
}
@CheckForNull
public E ceiling(@ParametricNullness E e) {
return Iterables.find(unfiltered().tailSet(e, true), this.predicate, null);
}
@CheckForNull
public E higher(@ParametricNullness E e) {
return Iterables.find(unfiltered().tailSet(e, false), this.predicate, null);
}
@CheckForNull
public E pollFirst() {
return Iterables.removeFirstMatching(unfiltered(), this.predicate);
}
@CheckForNull
public E pollLast() {
return Iterables.removeFirstMatching(unfiltered().descendingSet(), this.predicate);
}
public NavigableSet<E> descendingSet() {
return Sets.filter(unfiltered().descendingSet(), this.predicate);
}
public Iterator<E> descendingIterator() {
return Iterators.filter(unfiltered().descendingIterator(), this.predicate);
}
@ParametricNullness
public E last() {
return Iterators.find(unfiltered().descendingIterator(), this.predicate);
}
public NavigableSet<E> subSet(@ParametricNullness E e, boolean z, @ParametricNullness E e2, boolean z2) {
return Sets.filter(unfiltered().subSet(e, z, e2, z2), this.predicate);
}
public NavigableSet<E> headSet(@ParametricNullness E e, boolean z) {
return Sets.filter(unfiltered().headSet(e, z), this.predicate);
}
public NavigableSet<E> tailSet(@ParametricNullness E e, boolean z) {
return Sets.filter(unfiltered().tailSet(e, z), this.predicate);
}
}
public static <B> Set<List<B>> cartesianProduct(List<? extends Set<? extends B>> list) {
return CartesianSet.create(list);
}
@SafeVarargs
public static <B> Set<List<B>> cartesianProduct(Set<? extends B>... setArr) {
return cartesianProduct(Arrays.asList(setArr));
}
private static final class CartesianSet<E> extends ForwardingCollection<List<E>> implements Set<List<E>> {
private final transient ImmutableList<ImmutableSet<E>> axes;
private final transient CartesianList<E> delegate;
static <E> Set<List<E>> create(List<? extends Set<? extends E>> list) {
ImmutableList.Builder builder = new ImmutableList.Builder(list.size());
for (Set copyOf : list) {
ImmutableSet copyOf2 = ImmutableSet.copyOf(copyOf);
if (copyOf2.isEmpty()) {
return ImmutableSet.of();
}
builder.add((Object) copyOf2);
}
final ImmutableList build = builder.build();
return new CartesianSet(build, new CartesianList(new ImmutableList<List<E>>() {
/* access modifiers changed from: package-private */
public boolean isPartialView() {
return true;
}
public int size() {
return ImmutableList.this.size();
}
public List<E> get(int i) {
return ((ImmutableSet) ImmutableList.this.get(i)).asList();
}
}));
}
private CartesianSet(ImmutableList<ImmutableSet<E>> immutableList, CartesianList<E> cartesianList) {
this.axes = immutableList;
this.delegate = cartesianList;
}
/* access modifiers changed from: protected */
public Collection<List<E>> delegate() {
return this.delegate;
}
public boolean contains(@CheckForNull Object obj) {
if (!(obj instanceof List)) {
return false;
}
List<Object> list = (List) obj;
if (list.size() != this.axes.size()) {
return false;
}
int i = 0;
for (Object contains : list) {
if (!((ImmutableSet) this.axes.get(i)).contains(contains)) {
return false;
}
i++;
}
return true;
}
public boolean equals(@CheckForNull Object obj) {
if (obj instanceof CartesianSet) {
return this.axes.equals(((CartesianSet) obj).axes);
}
return super.equals(obj);
}
public int hashCode() {
int i = 1;
int size = size() - 1;
for (int i2 = 0; i2 < this.axes.size(); i2++) {
size = ~(~(size * 31));
}
UnmodifiableIterator<ImmutableSet<E>> it = this.axes.iterator();
while (it.hasNext()) {
Set next = it.next();
i = ~(~((i * 31) + ((size() / next.size()) * next.hashCode())));
}
return ~(~(i + size));
}
}
public static <E> Set<Set<E>> powerSet(Set<E> set) {
return new PowerSet(set);
}
private static final class SubSet<E> extends AbstractSet<E> {
/* access modifiers changed from: private */
public final ImmutableMap<E, Integer> inputSet;
/* access modifiers changed from: private */
public final int mask;
SubSet(ImmutableMap<E, Integer> immutableMap, int i) {
this.inputSet = immutableMap;
this.mask = i;
}
public Iterator<E> iterator() {
return new UnmodifiableIterator<E>() {
final ImmutableList<E> elements;
int remainingSetBits;
{
this.elements = SubSet.this.inputSet.keySet().asList();
this.remainingSetBits = SubSet.this.mask;
}
public boolean hasNext() {
return this.remainingSetBits != 0;
}
public E next() {
int numberOfTrailingZeros = Integer.numberOfTrailingZeros(this.remainingSetBits);
if (numberOfTrailingZeros != 32) {
this.remainingSetBits &= ~(1 << numberOfTrailingZeros);
return this.elements.get(numberOfTrailingZeros);
}
throw new NoSuchElementException();
}
};
}
public int size() {
return Integer.bitCount(this.mask);
}
public boolean contains(@CheckForNull Object obj) {
Integer num = this.inputSet.get(obj);
if (num != null) {
if (((1 << num.intValue()) & this.mask) != 0) {
return true;
}
}
return false;
}
}
private static final class PowerSet<E> extends AbstractSet<Set<E>> {
final ImmutableMap<E, Integer> inputSet;
public boolean isEmpty() {
return false;
}
PowerSet(Set<E> set) {
Preconditions.checkArgument(set.size() <= 30, "Too many elements to create power set: %s > 30", set.size());
this.inputSet = Maps.indexMap(set);
}
public int size() {
return 1 << this.inputSet.size();
}
public Iterator<Set<E>> iterator() {
return new AbstractIndexedListIterator<Set<E>>(size()) {
/* access modifiers changed from: protected */
public Set<E> get(int i) {
return new SubSet(PowerSet.this.inputSet, i);
}
};
}
public boolean contains(@CheckForNull Object obj) {
if (!(obj instanceof Set)) {
return false;
}
return this.inputSet.keySet().containsAll((Set) obj);
}
public boolean equals(@CheckForNull Object obj) {
if (obj instanceof PowerSet) {
return this.inputSet.keySet().equals(((PowerSet) obj).inputSet.keySet());
}
return super.equals(obj);
}
public int hashCode() {
return this.inputSet.keySet().hashCode() << (this.inputSet.size() - 1);
}
public String toString() {
String valueOf = String.valueOf(this.inputSet);
StringBuilder sb = new StringBuilder(String.valueOf(valueOf).length() + 10);
sb.append("powerSet(");
sb.append(valueOf);
sb.append(")");
return sb.toString();
}
}
public static <E> Set<Set<E>> combinations(Set<E> set, final int i) {
final ImmutableMap<E, Integer> indexMap = Maps.indexMap(set);
CollectPreconditions.checkNonnegative(i, "size");
Preconditions.checkArgument(i <= indexMap.size(), "size (%s) must be <= set.size() (%s)", i, indexMap.size());
if (i == 0) {
return ImmutableSet.of(ImmutableSet.of());
}
if (i == indexMap.size()) {
return ImmutableSet.of(indexMap.keySet());
}
return new AbstractSet<Set<E>>() {
public boolean contains(@CheckForNull Object obj) {
if (!(obj instanceof Set)) {
return false;
}
Set set = (Set) obj;
if (set.size() != i || !indexMap.keySet().containsAll(set)) {
return false;
}
return true;
}
public Iterator<Set<E>> iterator() {
return new AbstractIterator<Set<E>>() {
final BitSet bits;
{
this.bits = new BitSet(indexMap.size());
}
/* access modifiers changed from: protected */
@CheckForNull
public Set<E> computeNext() {
if (this.bits.isEmpty()) {
this.bits.set(0, i);
} else {
int nextSetBit = this.bits.nextSetBit(0);
int nextClearBit = this.bits.nextClearBit(nextSetBit);
if (nextClearBit == indexMap.size()) {
return (Set) endOfData();
}
int i = (nextClearBit - nextSetBit) - 1;
this.bits.set(0, i);
this.bits.clear(i, nextClearBit);
this.bits.set(nextClearBit);
}
final BitSet bitSet = (BitSet) this.bits.clone();
return new AbstractSet<E>() {
public boolean contains(@CheckForNull Object obj) {
Integer num = (Integer) indexMap.get(obj);
return num != null && bitSet.get(num.intValue());
}
public Iterator<E> iterator() {
return new AbstractIterator<E>() {
int i = -1;
/* access modifiers changed from: protected */
@CheckForNull
public E computeNext() {
int nextSetBit = bitSet.nextSetBit(this.i + 1);
this.i = nextSetBit;
if (nextSetBit == -1) {
return endOfData();
}
return indexMap.keySet().asList().get(this.i);
}
};
}
public int size() {
return i;
}
};
}
};
}
public int size() {
return IntMath.binomial(indexMap.size(), i);
}
public String toString() {
String valueOf = String.valueOf(indexMap.keySet());
int i = i;
StringBuilder sb = new StringBuilder(String.valueOf(valueOf).length() + 32);
sb.append("Sets.combinations(");
sb.append(valueOf);
sb.append(", ");
sb.append(i);
sb.append(")");
return sb.toString();
}
};
}
static int hashCodeImpl(Set<?> set) {
Iterator<?> it = set.iterator();
int i = 0;
while (it.hasNext()) {
Object next = it.next();
i = ~(~(i + (next != null ? next.hashCode() : 0)));
}
return i;
}
static boolean equalsImpl(Set<?> set, @CheckForNull Object obj) {
if (set == obj) {
return true;
}
if (obj instanceof Set) {
Set set2 = (Set) obj;
try {
if (set.size() != set2.size() || !set.containsAll(set2)) {
return false;
}
return true;
} catch (ClassCastException | NullPointerException unused) {
}
}
return false;
}
public static <E> NavigableSet<E> unmodifiableNavigableSet(NavigableSet<E> navigableSet) {
return ((navigableSet instanceof ImmutableCollection) || (navigableSet instanceof UnmodifiableNavigableSet)) ? navigableSet : new UnmodifiableNavigableSet(navigableSet);
}
static final class UnmodifiableNavigableSet<E> extends ForwardingSortedSet<E> implements NavigableSet<E>, Serializable {
private static final long serialVersionUID = 0;
private final NavigableSet<E> delegate;
@CheckForNull
private transient UnmodifiableNavigableSet<E> descendingSet;
private final SortedSet<E> unmodifiableDelegate;
UnmodifiableNavigableSet(NavigableSet<E> navigableSet) {
this.delegate = (NavigableSet) Preconditions.checkNotNull(navigableSet);
this.unmodifiableDelegate = Collections.unmodifiableSortedSet(navigableSet);
}
/* access modifiers changed from: protected */
public SortedSet<E> delegate() {
return this.unmodifiableDelegate;
}
@CheckForNull
public E lower(@ParametricNullness E e) {
return this.delegate.lower(e);
}
@CheckForNull
public E floor(@ParametricNullness E e) {
return this.delegate.floor(e);
}
@CheckForNull
public E ceiling(@ParametricNullness E e) {
return this.delegate.ceiling(e);
}
@CheckForNull
public E higher(@ParametricNullness E e) {
return this.delegate.higher(e);
}
@CheckForNull
public E pollFirst() {
throw new UnsupportedOperationException();
}
@CheckForNull
public E pollLast() {
throw new UnsupportedOperationException();
}
public NavigableSet<E> descendingSet() {
UnmodifiableNavigableSet<E> unmodifiableNavigableSet = this.descendingSet;
if (unmodifiableNavigableSet != null) {
return unmodifiableNavigableSet;
}
UnmodifiableNavigableSet<E> unmodifiableNavigableSet2 = new UnmodifiableNavigableSet<>(this.delegate.descendingSet());
this.descendingSet = unmodifiableNavigableSet2;
unmodifiableNavigableSet2.descendingSet = this;
return unmodifiableNavigableSet2;
}
public Iterator<E> descendingIterator() {
return Iterators.unmodifiableIterator(this.delegate.descendingIterator());
}
public NavigableSet<E> subSet(@ParametricNullness E e, boolean z, @ParametricNullness E e2, boolean z2) {
return Sets.unmodifiableNavigableSet(this.delegate.subSet(e, z, e2, z2));
}
public NavigableSet<E> headSet(@ParametricNullness E e, boolean z) {
return Sets.unmodifiableNavigableSet(this.delegate.headSet(e, z));
}
public NavigableSet<E> tailSet(@ParametricNullness E e, boolean z) {
return Sets.unmodifiableNavigableSet(this.delegate.tailSet(e, z));
}
}
public static <E> NavigableSet<E> synchronizedNavigableSet(NavigableSet<E> navigableSet) {
return Synchronized.navigableSet(navigableSet);
}
static boolean removeAllImpl(Set<?> set, Iterator<?> it) {
boolean z = false;
while (it.hasNext()) {
z |= set.remove(it.next());
}
return z;
}
static boolean removeAllImpl(Set<?> set, Collection<?> collection) {
Preconditions.checkNotNull(collection);
if (collection instanceof Multiset) {
collection = ((Multiset) collection).elementSet();
}
if (!(collection instanceof Set) || collection.size() <= set.size()) {
return removeAllImpl(set, collection.iterator());
}
return Iterators.removeAll(set.iterator(), collection);
}
static class DescendingSet<E> extends ForwardingNavigableSet<E> {
private final NavigableSet<E> forward;
DescendingSet(NavigableSet<E> navigableSet) {
this.forward = navigableSet;
}
/* access modifiers changed from: protected */
public NavigableSet<E> delegate() {
return this.forward;
}
@CheckForNull
public E lower(@ParametricNullness E e) {
return this.forward.higher(e);
}
@CheckForNull
public E floor(@ParametricNullness E e) {
return this.forward.ceiling(e);
}
@CheckForNull
public E ceiling(@ParametricNullness E e) {
return this.forward.floor(e);
}
@CheckForNull
public E higher(@ParametricNullness E e) {
return this.forward.lower(e);
}
@CheckForNull
public E pollFirst() {
return this.forward.pollLast();
}
@CheckForNull
public E pollLast() {
return this.forward.pollFirst();
}
public NavigableSet<E> descendingSet() {
return this.forward;
}
public Iterator<E> descendingIterator() {
return this.forward.iterator();
}
public NavigableSet<E> subSet(@ParametricNullness E e, boolean z, @ParametricNullness E e2, boolean z2) {
return this.forward.subSet(e2, z2, e, z).descendingSet();
}
public SortedSet<E> subSet(@ParametricNullness E e, @ParametricNullness E e2) {
return standardSubSet(e, e2);
}
public NavigableSet<E> headSet(@ParametricNullness E e, boolean z) {
return this.forward.tailSet(e, z).descendingSet();
}
public SortedSet<E> headSet(@ParametricNullness E e) {
return standardHeadSet(e);
}
public NavigableSet<E> tailSet(@ParametricNullness E e, boolean z) {
return this.forward.headSet(e, z).descendingSet();
}
public SortedSet<E> tailSet(@ParametricNullness E e) {
return standardTailSet(e);
}
public Comparator<? super E> comparator() {
Comparator comparator = this.forward.comparator();
if (comparator == null) {
return Ordering.natural().reverse();
}
return reverse(comparator);
}
private static <T> Ordering<T> reverse(Comparator<T> comparator) {
return Ordering.from(comparator).reverse();
}
@ParametricNullness
public E first() {
return this.forward.last();
}
@ParametricNullness
public E last() {
return this.forward.first();
}
public Iterator<E> iterator() {
return this.forward.descendingIterator();
}
public Object[] toArray() {
return standardToArray();
}
public <T> T[] toArray(T[] tArr) {
return standardToArray(tArr);
}
public String toString() {
return standardToString();
}
}
public static <K extends Comparable<? super K>> NavigableSet<K> subSet(NavigableSet<K> navigableSet, Range<K> range) {
boolean z = true;
if (navigableSet.comparator() != null && navigableSet.comparator() != Ordering.natural() && range.hasLowerBound() && range.hasUpperBound()) {
Preconditions.checkArgument(navigableSet.comparator().compare(range.lowerEndpoint(), range.upperEndpoint()) <= 0, "set is using a custom comparator which is inconsistent with the natural ordering.");
}
if (range.hasLowerBound() && range.hasUpperBound()) {
K lowerEndpoint = range.lowerEndpoint();
boolean z2 = range.lowerBoundType() == BoundType.CLOSED;
K upperEndpoint = range.upperEndpoint();
if (range.upperBoundType() != BoundType.CLOSED) {
z = false;
}
return navigableSet.subSet(lowerEndpoint, z2, upperEndpoint, z);
} else if (range.hasLowerBound()) {
K lowerEndpoint2 = range.lowerEndpoint();
if (range.lowerBoundType() != BoundType.CLOSED) {
z = false;
}
return navigableSet.tailSet(lowerEndpoint2, z);
} else if (!range.hasUpperBound()) {
return (NavigableSet) Preconditions.checkNotNull(navigableSet);
} else {
K upperEndpoint2 = range.upperEndpoint();
if (range.upperBoundType() != BoundType.CLOSED) {
z = false;
}
return navigableSet.headSet(upperEndpoint2, z);
}
}
}
Download file