CrackMe.apk
Download file
package com.google.common.collect;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableCollection;
import com.google.common.collect.ImmutableMap;
import java.util.AbstractMap;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Map;
import java.util.NavigableMap;
import java.util.Objects;
import java.util.SortedMap;
import javax.annotation.CheckForNull;
@ElementTypesAreNonnullByDefault
public final class ImmutableSortedMap<K, V> extends ImmutableSortedMapFauxverideShim<K, V> implements NavigableMap<K, V> {
private static final ImmutableSortedMap<Comparable, Object> NATURAL_EMPTY_MAP = new ImmutableSortedMap<>(ImmutableSortedSet.emptySet(Ordering.natural()), ImmutableList.of());
private static final Comparator<Comparable> NATURAL_ORDER = Ordering.natural();
private static final long serialVersionUID = 0;
@CheckForNull
private transient ImmutableSortedMap<K, V> descendingMap;
/* access modifiers changed from: private */
public final transient RegularImmutableSortedSet<K> keySet;
/* access modifiers changed from: private */
public final transient ImmutableList<V> valueList;
static <K, V> ImmutableSortedMap<K, V> emptyMap(Comparator<? super K> comparator) {
if (Ordering.natural().equals(comparator)) {
return of();
}
return new ImmutableSortedMap<>(ImmutableSortedSet.emptySet(comparator), ImmutableList.of());
}
public static <K, V> ImmutableSortedMap<K, V> of() {
return NATURAL_EMPTY_MAP;
}
public static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> of(K k, V v) {
return of(Ordering.natural(), k, v);
}
/* access modifiers changed from: private */
public static <K, V> ImmutableSortedMap<K, V> of(Comparator<? super K> comparator, K k, V v) {
return new ImmutableSortedMap<>(new RegularImmutableSortedSet(ImmutableList.of(k), (Comparator) Preconditions.checkNotNull(comparator)), ImmutableList.of(v));
}
public static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> of(K k, V v, K k2, V v2) {
return fromEntries(entryOf(k, v), entryOf(k2, v2));
}
public static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> of(K k, V v, K k2, V v2, K k3, V v3) {
return fromEntries(entryOf(k, v), entryOf(k2, v2), entryOf(k3, v3));
}
public static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> of(K k, V v, K k2, V v2, K k3, V v3, K k4, V v4) {
return fromEntries(entryOf(k, v), entryOf(k2, v2), entryOf(k3, v3), entryOf(k4, v4));
}
public static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> of(K k, V v, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5) {
return fromEntries(entryOf(k, v), entryOf(k2, v2), entryOf(k3, v3), entryOf(k4, v4), entryOf(k5, v5));
}
public static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> of(K k, V v, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6) {
return fromEntries(entryOf(k, v), entryOf(k2, v2), entryOf(k3, v3), entryOf(k4, v4), entryOf(k5, v5), entryOf(k6, v6));
}
public static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> of(K k, V v, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7) {
return fromEntries(entryOf(k, v), entryOf(k2, v2), entryOf(k3, v3), entryOf(k4, v4), entryOf(k5, v5), entryOf(k6, v6), entryOf(k7, v7));
}
public static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> of(K k, V v, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8) {
return fromEntries(entryOf(k, v), entryOf(k2, v2), entryOf(k3, v3), entryOf(k4, v4), entryOf(k5, v5), entryOf(k6, v6), entryOf(k7, v7), entryOf(k8, v8));
}
public static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> of(K k, V v, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9) {
return fromEntries(entryOf(k, v), entryOf(k2, v2), entryOf(k3, v3), entryOf(k4, v4), entryOf(k5, v5), entryOf(k6, v6), entryOf(k7, v7), entryOf(k8, v8), entryOf(k9, v9));
}
public static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> of(K k, V v, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10) {
return fromEntries(entryOf(k, v), entryOf(k2, v2), entryOf(k3, v3), entryOf(k4, v4), entryOf(k5, v5), entryOf(k6, v6), entryOf(k7, v7), entryOf(k8, v8), entryOf(k9, v9), entryOf(k10, v10));
}
public static <K, V> ImmutableSortedMap<K, V> copyOf(Map<? extends K, ? extends V> map) {
return copyOfInternal(map, (Ordering) NATURAL_ORDER);
}
public static <K, V> ImmutableSortedMap<K, V> copyOf(Map<? extends K, ? extends V> map, Comparator<? super K> comparator) {
return copyOfInternal(map, (Comparator) Preconditions.checkNotNull(comparator));
}
public static <K, V> ImmutableSortedMap<K, V> copyOf(Iterable<? extends Map.Entry<? extends K, ? extends V>> iterable) {
return copyOf(iterable, (Ordering) NATURAL_ORDER);
}
public static <K, V> ImmutableSortedMap<K, V> copyOf(Iterable<? extends Map.Entry<? extends K, ? extends V>> iterable, Comparator<? super K> comparator) {
return fromEntries((Comparator) Preconditions.checkNotNull(comparator), false, iterable);
}
/* JADX WARNING: type inference failed for: r3v0, types: [java.util.SortedMap<K, ? extends V>, java.util.SortedMap] */
/* JADX WARNING: Unknown variable types count: 1 */
/* Code decompiled incorrectly, please refer to instructions dump. */
public static <K, V> com.google.common.collect.ImmutableSortedMap<K, V> copyOfSorted(java.util.SortedMap<K, ? extends V> r3) {
/*
java.util.Comparator r0 = r3.comparator()
if (r0 != 0) goto L_0x0008
java.util.Comparator<java.lang.Comparable> r0 = NATURAL_ORDER
L_0x0008:
boolean r1 = r3 instanceof com.google.common.collect.ImmutableSortedMap
if (r1 == 0) goto L_0x0016
r1 = r3
com.google.common.collect.ImmutableSortedMap r1 = (com.google.common.collect.ImmutableSortedMap) r1
boolean r2 = r1.isPartialView()
if (r2 != 0) goto L_0x0016
return r1
L_0x0016:
r1 = 1
java.util.Set r3 = r3.entrySet()
com.google.common.collect.ImmutableSortedMap r3 = fromEntries(r0, r1, r3)
return r3
*/
throw new UnsupportedOperationException("Method not decompiled: com.google.common.collect.ImmutableSortedMap.copyOfSorted(java.util.SortedMap):com.google.common.collect.ImmutableSortedMap");
}
private static <K, V> ImmutableSortedMap<K, V> copyOfInternal(Map<? extends K, ? extends V> map, Comparator<? super K> comparator) {
boolean z = false;
if (map instanceof SortedMap) {
Comparator comparator2 = ((SortedMap) map).comparator();
if (comparator2 != null) {
z = comparator.equals(comparator2);
} else if (comparator == NATURAL_ORDER) {
z = true;
}
}
if (z && (map instanceof ImmutableSortedMap)) {
ImmutableSortedMap<K, V> immutableSortedMap = (ImmutableSortedMap) map;
if (!immutableSortedMap.isPartialView()) {
return immutableSortedMap;
}
}
return fromEntries(comparator, z, map.entrySet());
}
private static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> fromEntries(Map.Entry<K, V>... entryArr) {
return fromEntries(Ordering.natural(), false, entryArr, entryArr.length);
}
private static <K, V> ImmutableSortedMap<K, V> fromEntries(Comparator<? super K> comparator, boolean z, Iterable<? extends Map.Entry<? extends K, ? extends V>> iterable) {
Map.Entry[] entryArr = (Map.Entry[]) Iterables.toArray(iterable, (T[]) EMPTY_ENTRY_ARRAY);
return fromEntries(comparator, z, entryArr, entryArr.length);
}
private static <K, V> ImmutableSortedMap<K, V> fromEntries(final Comparator<? super K> comparator, boolean z, Map.Entry<K, V>[] entryArr, int i) {
if (i == 0) {
return emptyMap(comparator);
}
if (i != 1) {
Object[] objArr = new Object[i];
Object[] objArr2 = new Object[i];
if (z) {
for (int i2 = 0; i2 < i; i2++) {
Map.Entry<K, V> entry = entryArr[i2];
Objects.requireNonNull(entry);
Map.Entry entry2 = entry;
K key = entry.getKey();
V value = entry.getValue();
CollectPreconditions.checkEntryNotNull(key, value);
objArr[i2] = key;
objArr2[i2] = value;
}
} else {
Arrays.sort(entryArr, 0, i, new Comparator<Map.Entry<K, V>>() {
public int compare(@CheckForNull Map.Entry<K, V> entry, @CheckForNull Map.Entry<K, V> entry2) {
Objects.requireNonNull(entry);
Objects.requireNonNull(entry2);
return comparator.compare(entry.getKey(), entry2.getKey());
}
});
Map.Entry<K, V> entry3 = entryArr[0];
Objects.requireNonNull(entry3);
Map.Entry entry4 = entry3;
K key2 = entry3.getKey();
objArr[0] = key2;
objArr2[0] = entry3.getValue();
CollectPreconditions.checkEntryNotNull(objArr[0], objArr2[0]);
int i3 = 1;
while (i3 < i) {
Map.Entry<K, V> entry5 = entryArr[i3 - 1];
Objects.requireNonNull(entry5);
Map.Entry entry6 = entry5;
Map.Entry<K, V> entry7 = entryArr[i3];
Objects.requireNonNull(entry7);
Map.Entry entry8 = entry7;
K key3 = entry7.getKey();
V value2 = entry7.getValue();
CollectPreconditions.checkEntryNotNull(key3, value2);
objArr[i3] = key3;
objArr2[i3] = value2;
checkNoConflict(comparator.compare(key2, key3) != 0, "key", entry5, entry7);
i3++;
key2 = key3;
}
}
return new ImmutableSortedMap<>(new RegularImmutableSortedSet(ImmutableList.asImmutableList(objArr), comparator), ImmutableList.asImmutableList(objArr2));
}
Map.Entry<K, V> entry9 = entryArr[0];
Objects.requireNonNull(entry9);
Map.Entry entry10 = entry9;
return of(comparator, entry9.getKey(), entry9.getValue());
}
public static <K extends Comparable<?>, V> Builder<K, V> naturalOrder() {
return new Builder<>(Ordering.natural());
}
public static <K, V> Builder<K, V> orderedBy(Comparator<K> comparator) {
return new Builder<>(comparator);
}
public static <K extends Comparable<?>, V> Builder<K, V> reverseOrder() {
return new Builder<>(Ordering.natural().reverse());
}
public static class Builder<K, V> extends ImmutableMap.Builder<K, V> {
private final Comparator<? super K> comparator;
private transient Object[] keys;
private transient Object[] values;
public Builder(Comparator<? super K> comparator2) {
this(comparator2, 4);
}
private Builder(Comparator<? super K> comparator2, int i) {
this.comparator = (Comparator) Preconditions.checkNotNull(comparator2);
this.keys = new Object[i];
this.values = new Object[i];
}
private void ensureCapacity(int i) {
Object[] objArr = this.keys;
if (i > objArr.length) {
int expandedCapacity = ImmutableCollection.Builder.expandedCapacity(objArr.length, i);
this.keys = Arrays.copyOf(this.keys, expandedCapacity);
this.values = Arrays.copyOf(this.values, expandedCapacity);
}
}
public Builder<K, V> put(K k, V v) {
ensureCapacity(this.size + 1);
CollectPreconditions.checkEntryNotNull(k, v);
this.keys[this.size] = k;
this.values[this.size] = v;
this.size++;
return this;
}
public Builder<K, V> put(Map.Entry<? extends K, ? extends V> entry) {
super.put(entry);
return this;
}
public Builder<K, V> putAll(Map<? extends K, ? extends V> map) {
super.putAll(map);
return this;
}
public Builder<K, V> putAll(Iterable<? extends Map.Entry<? extends K, ? extends V>> iterable) {
super.putAll(iterable);
return this;
}
@Deprecated
public final Builder<K, V> orderEntriesByValue(Comparator<? super V> comparator2) {
throw new UnsupportedOperationException("Not available on ImmutableSortedMap.Builder");
}
/* access modifiers changed from: package-private */
public Builder<K, V> combine(Builder<K, V> builder) {
ensureCapacity(this.size + builder.size);
System.arraycopy(builder.keys, 0, this.keys, this.size, builder.size);
System.arraycopy(builder.values, 0, this.values, this.size, builder.size);
this.size += builder.size;
return this;
}
public ImmutableSortedMap<K, V> build() {
return buildOrThrow();
}
public ImmutableSortedMap<K, V> buildOrThrow() {
int i = this.size;
if (i == 0) {
return ImmutableSortedMap.emptyMap(this.comparator);
}
if (i != 1) {
Object[] copyOf = Arrays.copyOf(this.keys, this.size);
Arrays.sort(copyOf, this.comparator);
Object[] objArr = new Object[this.size];
for (int i2 = 0; i2 < this.size; i2++) {
if (i2 > 0) {
int i3 = i2 - 1;
if (this.comparator.compare(copyOf[i3], copyOf[i2]) == 0) {
String valueOf = String.valueOf(copyOf[i3]);
String valueOf2 = String.valueOf(copyOf[i2]);
StringBuilder sb = new StringBuilder(String.valueOf(valueOf).length() + 57 + String.valueOf(valueOf2).length());
sb.append("keys required to be distinct but compared as equal: ");
sb.append(valueOf);
sb.append(" and ");
sb.append(valueOf2);
throw new IllegalArgumentException(sb.toString());
}
}
Object obj = this.keys[i2];
Objects.requireNonNull(obj);
int binarySearch = Arrays.binarySearch(copyOf, obj, this.comparator);
Object obj2 = this.values[i2];
Objects.requireNonNull(obj2);
objArr[binarySearch] = obj2;
}
return new ImmutableSortedMap<>(new RegularImmutableSortedSet(ImmutableList.asImmutableList(copyOf), this.comparator), ImmutableList.asImmutableList(objArr));
}
Comparator<? super K> comparator2 = this.comparator;
Object obj3 = this.keys[0];
Objects.requireNonNull(obj3);
Object obj4 = this.values[0];
Objects.requireNonNull(obj4);
return ImmutableSortedMap.of(comparator2, obj3, obj4);
}
}
ImmutableSortedMap(RegularImmutableSortedSet<K> regularImmutableSortedSet, ImmutableList<V> immutableList) {
this(regularImmutableSortedSet, immutableList, (ImmutableSortedMap) null);
}
ImmutableSortedMap(RegularImmutableSortedSet<K> regularImmutableSortedSet, ImmutableList<V> immutableList, @CheckForNull ImmutableSortedMap<K, V> immutableSortedMap) {
this.keySet = regularImmutableSortedSet;
this.valueList = immutableList;
this.descendingMap = immutableSortedMap;
}
public int size() {
return this.valueList.size();
}
@CheckForNull
public V get(@CheckForNull Object obj) {
int indexOf = this.keySet.indexOf(obj);
if (indexOf == -1) {
return null;
}
return this.valueList.get(indexOf);
}
/* access modifiers changed from: package-private */
public boolean isPartialView() {
return this.keySet.isPartialView() || this.valueList.isPartialView();
}
public ImmutableSet<Map.Entry<K, V>> entrySet() {
return super.entrySet();
}
/* access modifiers changed from: package-private */
public ImmutableSet<Map.Entry<K, V>> createEntrySet() {
return isEmpty() ? ImmutableSet.of() : new ImmutableMapEntrySet<K, V>() {
public UnmodifiableIterator<Map.Entry<K, V>> iterator() {
return asList().iterator();
}
/* access modifiers changed from: package-private */
public ImmutableList<Map.Entry<K, V>> createAsList() {
return new ImmutableList<Map.Entry<K, V>>() {
/* access modifiers changed from: package-private */
public boolean isPartialView() {
return true;
}
public Map.Entry<K, V> get(int i) {
return new AbstractMap.SimpleImmutableEntry(ImmutableSortedMap.this.keySet.asList().get(i), ImmutableSortedMap.this.valueList.get(i));
}
public int size() {
return ImmutableSortedMap.this.size();
}
};
}
/* access modifiers changed from: package-private */
public ImmutableMap<K, V> map() {
return ImmutableSortedMap.this;
}
};
}
public ImmutableSortedSet<K> keySet() {
return this.keySet;
}
/* access modifiers changed from: package-private */
public ImmutableSet<K> createKeySet() {
throw new AssertionError("should never be called");
}
public ImmutableCollection<V> values() {
return this.valueList;
}
/* access modifiers changed from: package-private */
public ImmutableCollection<V> createValues() {
throw new AssertionError("should never be called");
}
public Comparator<? super K> comparator() {
return keySet().comparator();
}
public K firstKey() {
return keySet().first();
}
public K lastKey() {
return keySet().last();
}
private ImmutableSortedMap<K, V> getSubMap(int i, int i2) {
if (i == 0 && i2 == size()) {
return this;
}
if (i == i2) {
return emptyMap(comparator());
}
return new ImmutableSortedMap<>(this.keySet.getSubSet(i, i2), this.valueList.subList(i, i2));
}
public ImmutableSortedMap<K, V> headMap(K k) {
return headMap(k, false);
}
public ImmutableSortedMap<K, V> headMap(K k, boolean z) {
return getSubMap(0, this.keySet.headIndex(Preconditions.checkNotNull(k), z));
}
public ImmutableSortedMap<K, V> subMap(K k, K k2) {
return subMap(k, true, k2, false);
}
public ImmutableSortedMap<K, V> subMap(K k, boolean z, K k2, boolean z2) {
Preconditions.checkNotNull(k);
Preconditions.checkNotNull(k2);
Preconditions.checkArgument(comparator().compare(k, k2) <= 0, "expected fromKey <= toKey but %s > %s", (Object) k, (Object) k2);
return headMap(k2, z2).tailMap(k, z);
}
public ImmutableSortedMap<K, V> tailMap(K k) {
return tailMap(k, true);
}
public ImmutableSortedMap<K, V> tailMap(K k, boolean z) {
return getSubMap(this.keySet.tailIndex(Preconditions.checkNotNull(k), z), size());
}
@CheckForNull
public Map.Entry<K, V> lowerEntry(K k) {
return headMap(k, false).lastEntry();
}
@CheckForNull
public K lowerKey(K k) {
return Maps.keyOrNull(lowerEntry(k));
}
@CheckForNull
public Map.Entry<K, V> floorEntry(K k) {
return headMap(k, true).lastEntry();
}
@CheckForNull
public K floorKey(K k) {
return Maps.keyOrNull(floorEntry(k));
}
@CheckForNull
public Map.Entry<K, V> ceilingEntry(K k) {
return tailMap(k, true).firstEntry();
}
@CheckForNull
public K ceilingKey(K k) {
return Maps.keyOrNull(ceilingEntry(k));
}
@CheckForNull
public Map.Entry<K, V> higherEntry(K k) {
return tailMap(k, false).firstEntry();
}
@CheckForNull
public K higherKey(K k) {
return Maps.keyOrNull(higherEntry(k));
}
@CheckForNull
public Map.Entry<K, V> firstEntry() {
if (isEmpty()) {
return null;
}
return (Map.Entry) entrySet().asList().get(0);
}
@CheckForNull
public Map.Entry<K, V> lastEntry() {
if (isEmpty()) {
return null;
}
return (Map.Entry) entrySet().asList().get(size() - 1);
}
@CheckForNull
@Deprecated
public final Map.Entry<K, V> pollFirstEntry() {
throw new UnsupportedOperationException();
}
@CheckForNull
@Deprecated
public final Map.Entry<K, V> pollLastEntry() {
throw new UnsupportedOperationException();
}
public ImmutableSortedMap<K, V> descendingMap() {
ImmutableSortedMap<K, V> immutableSortedMap = this.descendingMap;
if (immutableSortedMap != null) {
return immutableSortedMap;
}
if (isEmpty()) {
return emptyMap(Ordering.from(comparator()).reverse());
}
return new ImmutableSortedMap<>((RegularImmutableSortedSet) this.keySet.descendingSet(), this.valueList.reverse(), this);
}
public ImmutableSortedSet<K> navigableKeySet() {
return this.keySet;
}
public ImmutableSortedSet<K> descendingKeySet() {
return this.keySet.descendingSet();
}
private static class SerializedForm<K, V> extends ImmutableMap.SerializedForm<K, V> {
private static final long serialVersionUID = 0;
private final Comparator<? super K> comparator;
SerializedForm(ImmutableSortedMap<K, V> immutableSortedMap) {
super(immutableSortedMap);
this.comparator = immutableSortedMap.comparator();
}
/* access modifiers changed from: package-private */
public Builder<K, V> makeBuilder(int i) {
return new Builder<>(this.comparator);
}
}
/* access modifiers changed from: package-private */
public Object writeReplace() {
return new SerializedForm(this);
}
}
Download file