CrackMe.apk
Download file
package com.google.common.collect;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMultiset;
import com.google.common.collect.Multiset;
import com.google.common.math.IntMath;
import com.google.errorprone.annotations.concurrent.LazyInit;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import javax.annotation.CheckForNull;
@ElementTypesAreNonnullByDefault
public abstract class ImmutableSortedMultiset<E> extends ImmutableSortedMultisetFauxverideShim<E> implements SortedMultiset<E> {
@CheckForNull
@LazyInit
transient ImmutableSortedMultiset<E> descendingMultiset;
public abstract ImmutableSortedSet<E> elementSet();
public abstract ImmutableSortedMultiset<E> headMultiset(E e, BoundType boundType);
public abstract ImmutableSortedMultiset<E> tailMultiset(E e, BoundType boundType);
public static <E> ImmutableSortedMultiset<E> of() {
return RegularImmutableSortedMultiset.NATURAL_EMPTY_MULTISET;
}
public static <E extends Comparable<? super E>> ImmutableSortedMultiset<E> of(E e) {
return new RegularImmutableSortedMultiset((RegularImmutableSortedSet) ImmutableSortedSet.of(e), new long[]{0, 1}, 0, 1);
}
public static <E extends Comparable<? super E>> ImmutableSortedMultiset<E> of(E e, E e2) {
return copyOf(Ordering.natural(), Arrays.asList(new Comparable[]{e, e2}));
}
public static <E extends Comparable<? super E>> ImmutableSortedMultiset<E> of(E e, E e2, E e3) {
return copyOf(Ordering.natural(), Arrays.asList(new Comparable[]{e, e2, e3}));
}
public static <E extends Comparable<? super E>> ImmutableSortedMultiset<E> of(E e, E e2, E e3, E e4) {
return copyOf(Ordering.natural(), Arrays.asList(new Comparable[]{e, e2, e3, e4}));
}
public static <E extends Comparable<? super E>> ImmutableSortedMultiset<E> of(E e, E e2, E e3, E e4, E e5) {
return copyOf(Ordering.natural(), Arrays.asList(new Comparable[]{e, e2, e3, e4, e5}));
}
public static <E extends Comparable<? super E>> ImmutableSortedMultiset<E> of(E e, E e2, E e3, E e4, E e5, E e6, E... eArr) {
ArrayList newArrayListWithCapacity = Lists.newArrayListWithCapacity(eArr.length + 6);
Collections.addAll(newArrayListWithCapacity, new Comparable[]{e, e2, e3, e4, e5, e6});
Collections.addAll(newArrayListWithCapacity, eArr);
return copyOf(Ordering.natural(), newArrayListWithCapacity);
}
public static <E extends Comparable<? super E>> ImmutableSortedMultiset<E> copyOf(E[] eArr) {
return copyOf(Ordering.natural(), Arrays.asList(eArr));
}
public static <E> ImmutableSortedMultiset<E> copyOf(Iterable<? extends E> iterable) {
return copyOf(Ordering.natural(), iterable);
}
public static <E> ImmutableSortedMultiset<E> copyOf(Iterator<? extends E> it) {
return copyOf(Ordering.natural(), it);
}
public static <E> ImmutableSortedMultiset<E> copyOf(Comparator<? super E> comparator, Iterator<? extends E> it) {
Preconditions.checkNotNull(comparator);
return new Builder(comparator).addAll((Iterator) it).build();
}
public static <E> ImmutableSortedMultiset<E> copyOf(Comparator<? super E> comparator, Iterable<? extends E> iterable) {
if (iterable instanceof ImmutableSortedMultiset) {
ImmutableSortedMultiset<E> immutableSortedMultiset = (ImmutableSortedMultiset) iterable;
if (comparator.equals(immutableSortedMultiset.comparator())) {
return immutableSortedMultiset.isPartialView() ? copyOfSortedEntries(comparator, immutableSortedMultiset.entrySet().asList()) : immutableSortedMultiset;
}
}
return new Builder(comparator).addAll((Iterable) iterable).build();
}
public static <E> ImmutableSortedMultiset<E> copyOfSorted(SortedMultiset<E> sortedMultiset) {
return copyOfSortedEntries(sortedMultiset.comparator(), Lists.newArrayList(sortedMultiset.entrySet()));
}
private static <E> ImmutableSortedMultiset<E> copyOfSortedEntries(Comparator<? super E> comparator, Collection<Multiset.Entry<E>> collection) {
if (collection.isEmpty()) {
return emptyMultiset(comparator);
}
ImmutableList.Builder builder = new ImmutableList.Builder(collection.size());
long[] jArr = new long[(collection.size() + 1)];
int i = 0;
for (Multiset.Entry next : collection) {
builder.add(next.getElement());
int i2 = i + 1;
jArr[i2] = jArr[i] + ((long) next.getCount());
i = i2;
}
return new RegularImmutableSortedMultiset(new RegularImmutableSortedSet(builder.build(), comparator), jArr, 0, collection.size());
}
static <E> ImmutableSortedMultiset<E> emptyMultiset(Comparator<? super E> comparator) {
if (Ordering.natural().equals(comparator)) {
return RegularImmutableSortedMultiset.NATURAL_EMPTY_MULTISET;
}
return new RegularImmutableSortedMultiset(comparator);
}
ImmutableSortedMultiset() {
}
public final Comparator<? super E> comparator() {
return elementSet().comparator();
}
public ImmutableSortedMultiset<E> descendingMultiset() {
ImmutableSortedMultiset<E> immutableSortedMultiset = this.descendingMultiset;
if (immutableSortedMultiset == null) {
if (isEmpty()) {
immutableSortedMultiset = emptyMultiset(Ordering.from(comparator()).reverse());
} else {
immutableSortedMultiset = new DescendingImmutableSortedMultiset<>(this);
}
this.descendingMultiset = immutableSortedMultiset;
}
return immutableSortedMultiset;
}
@CheckForNull
@Deprecated
public final Multiset.Entry<E> pollFirstEntry() {
throw new UnsupportedOperationException();
}
@CheckForNull
@Deprecated
public final Multiset.Entry<E> pollLastEntry() {
throw new UnsupportedOperationException();
}
public ImmutableSortedMultiset<E> subMultiset(E e, BoundType boundType, E e2, BoundType boundType2) {
Preconditions.checkArgument(comparator().compare(e, e2) <= 0, "Expected lowerBound <= upperBound but %s > %s", (Object) e, (Object) e2);
return tailMultiset(e, boundType).headMultiset(e2, boundType2);
}
public static <E> Builder<E> orderedBy(Comparator<E> comparator) {
return new Builder<>(comparator);
}
public static <E extends Comparable<?>> Builder<E> reverseOrder() {
return new Builder<>(Ordering.natural().reverse());
}
public static <E extends Comparable<?>> Builder<E> naturalOrder() {
return new Builder<>(Ordering.natural());
}
public static class Builder<E> extends ImmutableMultiset.Builder<E> {
private final Comparator<? super E> comparator;
private int[] counts = new int[4];
E[] elements = new Object[4];
private boolean forceCopyElements;
private int length;
public Builder(Comparator<? super E> comparator2) {
super(true);
this.comparator = (Comparator) Preconditions.checkNotNull(comparator2);
}
private void maintenance() {
int i = this.length;
E[] eArr = this.elements;
if (i == eArr.length) {
dedupAndCoalesce(true);
} else if (this.forceCopyElements) {
this.elements = Arrays.copyOf(eArr, eArr.length);
}
this.forceCopyElements = false;
}
private void dedupAndCoalesce(boolean z) {
int i = this.length;
if (i != 0) {
E[] copyOf = Arrays.copyOf(this.elements, i);
Arrays.sort(copyOf, this.comparator);
int i2 = 1;
for (int i3 = 1; i3 < copyOf.length; i3++) {
if (this.comparator.compare(copyOf[i2 - 1], copyOf[i3]) < 0) {
copyOf[i2] = copyOf[i3];
i2++;
}
}
Arrays.fill(copyOf, i2, this.length, (Object) null);
if (z) {
int i4 = i2 * 4;
int i5 = this.length;
if (i4 > i5 * 3) {
copyOf = Arrays.copyOf(copyOf, IntMath.saturatedAdd(i5, (i5 / 2) + 1));
}
}
int[] iArr = new int[copyOf.length];
for (int i6 = 0; i6 < this.length; i6++) {
int binarySearch = Arrays.binarySearch(copyOf, 0, i2, this.elements[i6], this.comparator);
int[] iArr2 = this.counts;
if (iArr2[i6] >= 0) {
iArr[binarySearch] = iArr[binarySearch] + iArr2[i6];
} else {
iArr[binarySearch] = ~iArr2[i6];
}
}
this.elements = copyOf;
this.counts = iArr;
this.length = i2;
}
}
public Builder<E> add(E e) {
return addCopies((Object) e, 1);
}
public Builder<E> add(E... eArr) {
for (E add : eArr) {
add((Object) add);
}
return this;
}
public Builder<E> addCopies(E e, int i) {
Preconditions.checkNotNull(e);
CollectPreconditions.checkNonnegative(i, "occurrences");
if (i == 0) {
return this;
}
maintenance();
E[] eArr = this.elements;
int i2 = this.length;
eArr[i2] = e;
this.counts[i2] = i;
this.length = i2 + 1;
return this;
}
public Builder<E> setCount(E e, int i) {
Preconditions.checkNotNull(e);
CollectPreconditions.checkNonnegative(i, "count");
maintenance();
E[] eArr = this.elements;
int i2 = this.length;
eArr[i2] = e;
this.counts[i2] = ~i;
this.length = i2 + 1;
return this;
}
public Builder<E> addAll(Iterable<? extends E> iterable) {
if (iterable instanceof Multiset) {
for (Multiset.Entry entry : ((Multiset) iterable).entrySet()) {
addCopies(entry.getElement(), entry.getCount());
}
} else {
for (Object add : iterable) {
add((Object) add);
}
}
return this;
}
public Builder<E> addAll(Iterator<? extends E> it) {
while (it.hasNext()) {
add((Object) it.next());
}
return this;
}
private void dedupAndCoalesceAndDeleteEmpty() {
dedupAndCoalesce(false);
int i = 0;
int i2 = 0;
while (true) {
int i3 = this.length;
if (i < i3) {
int[] iArr = this.counts;
if (iArr[i] > 0) {
E[] eArr = this.elements;
eArr[i2] = eArr[i];
iArr[i2] = iArr[i];
i2++;
}
i++;
} else {
Arrays.fill(this.elements, i2, i3, (Object) null);
Arrays.fill(this.counts, i2, this.length, 0);
this.length = i2;
return;
}
}
}
public ImmutableSortedMultiset<E> build() {
dedupAndCoalesceAndDeleteEmpty();
int i = this.length;
if (i == 0) {
return ImmutableSortedMultiset.emptyMultiset(this.comparator);
}
RegularImmutableSortedSet regularImmutableSortedSet = (RegularImmutableSortedSet) ImmutableSortedSet.construct(this.comparator, i, this.elements);
long[] jArr = new long[(this.length + 1)];
int i2 = 0;
while (i2 < this.length) {
int i3 = i2 + 1;
jArr[i3] = jArr[i2] + ((long) this.counts[i2]);
i2 = i3;
}
this.forceCopyElements = true;
return new RegularImmutableSortedMultiset(regularImmutableSortedSet, jArr, 0, this.length);
}
}
private static final class SerializedForm<E> implements Serializable {
final Comparator<? super E> comparator;
final int[] counts;
final E[] elements;
SerializedForm(SortedMultiset<E> sortedMultiset) {
this.comparator = sortedMultiset.comparator();
int size = sortedMultiset.entrySet().size();
this.elements = new Object[size];
this.counts = new int[size];
int i = 0;
for (Multiset.Entry next : sortedMultiset.entrySet()) {
this.elements[i] = next.getElement();
this.counts[i] = next.getCount();
i++;
}
}
/* access modifiers changed from: package-private */
public Object readResolve() {
int length = this.elements.length;
Builder builder = new Builder(this.comparator);
for (int i = 0; i < length; i++) {
builder.addCopies((Object) this.elements[i], this.counts[i]);
}
return builder.build();
}
}
/* access modifiers changed from: package-private */
public Object writeReplace() {
return new SerializedForm(this);
}
}
Download file