CrackMe.apk
Download file
package com.google.common.collect;
import com.google.common.base.Objects;
import com.google.common.base.Preconditions;
import com.google.common.collect.Sets;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Arrays;
import java.util.Collection;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;
import javax.annotation.CheckForNull;
@ElementTypesAreNonnullByDefault
public final class LinkedHashMultimap<K, V> extends LinkedHashMultimapGwtSerializationDependencies<K, V> {
private static final int DEFAULT_KEY_CAPACITY = 16;
private static final int DEFAULT_VALUE_SET_CAPACITY = 2;
static final double VALUE_SET_LOAD_FACTOR = 1.0d;
private static final long serialVersionUID = 1;
/* access modifiers changed from: private */
public transient ValueEntry<K, V> multimapHeaderEntry;
transient int valueSetCapacity = 2;
private interface ValueSetLink<K, V> {
ValueSetLink<K, V> getPredecessorInValueSet();
ValueSetLink<K, V> getSuccessorInValueSet();
void setPredecessorInValueSet(ValueSetLink<K, V> valueSetLink);
void setSuccessorInValueSet(ValueSetLink<K, V> valueSetLink);
}
public /* bridge */ /* synthetic */ Map asMap() {
return super.asMap();
}
public /* bridge */ /* synthetic */ boolean containsEntry(@CheckForNull Object obj, @CheckForNull Object obj2) {
return super.containsEntry(obj, obj2);
}
public /* bridge */ /* synthetic */ boolean containsKey(@CheckForNull Object obj) {
return super.containsKey(obj);
}
public /* bridge */ /* synthetic */ boolean containsValue(@CheckForNull Object obj) {
return super.containsValue(obj);
}
public /* bridge */ /* synthetic */ boolean equals(@CheckForNull Object obj) {
return super.equals(obj);
}
public /* bridge */ /* synthetic */ Set get(@ParametricNullness Object obj) {
return super.get(obj);
}
public /* bridge */ /* synthetic */ int hashCode() {
return super.hashCode();
}
public /* bridge */ /* synthetic */ boolean isEmpty() {
return super.isEmpty();
}
public /* bridge */ /* synthetic */ Multiset keys() {
return super.keys();
}
public /* bridge */ /* synthetic */ boolean put(@ParametricNullness Object obj, @ParametricNullness Object obj2) {
return super.put(obj, obj2);
}
public /* bridge */ /* synthetic */ boolean putAll(Multimap multimap) {
return super.putAll(multimap);
}
public /* bridge */ /* synthetic */ boolean putAll(@ParametricNullness Object obj, Iterable iterable) {
return super.putAll(obj, iterable);
}
public /* bridge */ /* synthetic */ boolean remove(@CheckForNull Object obj, @CheckForNull Object obj2) {
return super.remove(obj, obj2);
}
public /* bridge */ /* synthetic */ Set removeAll(@CheckForNull Object obj) {
return super.removeAll(obj);
}
public /* bridge */ /* synthetic */ int size() {
return super.size();
}
public /* bridge */ /* synthetic */ String toString() {
return super.toString();
}
public static <K, V> LinkedHashMultimap<K, V> create() {
return new LinkedHashMultimap<>(16, 2);
}
public static <K, V> LinkedHashMultimap<K, V> create(int i, int i2) {
return new LinkedHashMultimap<>(Maps.capacity(i), Maps.capacity(i2));
}
public static <K, V> LinkedHashMultimap<K, V> create(Multimap<? extends K, ? extends V> multimap) {
LinkedHashMultimap<K, V> create = create(multimap.keySet().size(), 2);
create.putAll(multimap);
return create;
}
/* access modifiers changed from: private */
public static <K, V> void succeedsInValueSet(ValueSetLink<K, V> valueSetLink, ValueSetLink<K, V> valueSetLink2) {
valueSetLink.setSuccessorInValueSet(valueSetLink2);
valueSetLink2.setPredecessorInValueSet(valueSetLink);
}
/* access modifiers changed from: private */
public static <K, V> void succeedsInMultimap(ValueEntry<K, V> valueEntry, ValueEntry<K, V> valueEntry2) {
valueEntry.setSuccessorInMultimap(valueEntry2);
valueEntry2.setPredecessorInMultimap(valueEntry);
}
/* access modifiers changed from: private */
public static <K, V> void deleteFromValueSet(ValueSetLink<K, V> valueSetLink) {
succeedsInValueSet(valueSetLink.getPredecessorInValueSet(), valueSetLink.getSuccessorInValueSet());
}
/* access modifiers changed from: private */
public static <K, V> void deleteFromMultimap(ValueEntry<K, V> valueEntry) {
succeedsInMultimap(valueEntry.getPredecessorInMultimap(), valueEntry.getSuccessorInMultimap());
}
static final class ValueEntry<K, V> extends ImmutableEntry<K, V> implements ValueSetLink<K, V> {
@CheckForNull
ValueEntry<K, V> nextInValueBucket;
@CheckForNull
ValueEntry<K, V> predecessorInMultimap;
@CheckForNull
ValueSetLink<K, V> predecessorInValueSet;
final int smearedValueHash;
@CheckForNull
ValueEntry<K, V> successorInMultimap;
@CheckForNull
ValueSetLink<K, V> successorInValueSet;
ValueEntry(@ParametricNullness K k, @ParametricNullness V v, int i, @CheckForNull ValueEntry<K, V> valueEntry) {
super(k, v);
this.smearedValueHash = i;
this.nextInValueBucket = valueEntry;
}
static <K, V> ValueEntry<K, V> newHeader() {
return new ValueEntry<>((Object) null, (Object) null, 0, (ValueEntry) null);
}
/* access modifiers changed from: package-private */
public boolean matchesValue(@CheckForNull Object obj, int i) {
return this.smearedValueHash == i && Objects.equal(getValue(), obj);
}
public ValueSetLink<K, V> getPredecessorInValueSet() {
ValueSetLink<K, V> valueSetLink = this.predecessorInValueSet;
java.util.Objects.requireNonNull(valueSetLink);
ValueSetLink valueSetLink2 = valueSetLink;
return valueSetLink;
}
public ValueSetLink<K, V> getSuccessorInValueSet() {
ValueSetLink<K, V> valueSetLink = this.successorInValueSet;
java.util.Objects.requireNonNull(valueSetLink);
ValueSetLink valueSetLink2 = valueSetLink;
return valueSetLink;
}
public void setPredecessorInValueSet(ValueSetLink<K, V> valueSetLink) {
this.predecessorInValueSet = valueSetLink;
}
public void setSuccessorInValueSet(ValueSetLink<K, V> valueSetLink) {
this.successorInValueSet = valueSetLink;
}
public ValueEntry<K, V> getPredecessorInMultimap() {
ValueEntry<K, V> valueEntry = this.predecessorInMultimap;
java.util.Objects.requireNonNull(valueEntry);
ValueEntry valueEntry2 = valueEntry;
return valueEntry;
}
public ValueEntry<K, V> getSuccessorInMultimap() {
ValueEntry<K, V> valueEntry = this.successorInMultimap;
java.util.Objects.requireNonNull(valueEntry);
ValueEntry valueEntry2 = valueEntry;
return valueEntry;
}
public void setSuccessorInMultimap(ValueEntry<K, V> valueEntry) {
this.successorInMultimap = valueEntry;
}
public void setPredecessorInMultimap(ValueEntry<K, V> valueEntry) {
this.predecessorInMultimap = valueEntry;
}
}
private LinkedHashMultimap(int i, int i2) {
super(Platform.newLinkedHashMapWithExpectedSize(i));
CollectPreconditions.checkNonnegative(i2, "expectedValuesPerKey");
this.valueSetCapacity = i2;
ValueEntry<K, V> newHeader = ValueEntry.newHeader();
this.multimapHeaderEntry = newHeader;
succeedsInMultimap(newHeader, newHeader);
}
/* access modifiers changed from: package-private */
public Set<V> createCollection() {
return Platform.newLinkedHashSetWithExpectedSize(this.valueSetCapacity);
}
/* access modifiers changed from: package-private */
public Collection<V> createCollection(@ParametricNullness K k) {
return new ValueSet(k, this.valueSetCapacity);
}
public Set<V> replaceValues(@ParametricNullness K k, Iterable<? extends V> iterable) {
return super.replaceValues((Object) k, (Iterable) iterable);
}
public Set<Map.Entry<K, V>> entries() {
return super.entries();
}
public Set<K> keySet() {
return super.keySet();
}
public Collection<V> values() {
return super.values();
}
final class ValueSet extends Sets.ImprovedAbstractSet<V> implements ValueSetLink<K, V> {
/* access modifiers changed from: private */
public ValueSetLink<K, V> firstEntry;
ValueEntry<K, V>[] hashTable;
@ParametricNullness
private final K key;
private ValueSetLink<K, V> lastEntry;
/* access modifiers changed from: private */
public int modCount = 0;
private int size = 0;
ValueSet(@ParametricNullness K k, int i) {
this.key = k;
this.firstEntry = this;
this.lastEntry = this;
this.hashTable = new ValueEntry[Hashing.closedTableSize(i, LinkedHashMultimap.VALUE_SET_LOAD_FACTOR)];
}
private int mask() {
return this.hashTable.length - 1;
}
public ValueSetLink<K, V> getPredecessorInValueSet() {
return this.lastEntry;
}
public ValueSetLink<K, V> getSuccessorInValueSet() {
return this.firstEntry;
}
public void setPredecessorInValueSet(ValueSetLink<K, V> valueSetLink) {
this.lastEntry = valueSetLink;
}
public void setSuccessorInValueSet(ValueSetLink<K, V> valueSetLink) {
this.firstEntry = valueSetLink;
}
public Iterator<V> iterator() {
return new Iterator<V>() {
int expectedModCount;
ValueSetLink<K, V> nextEntry;
@CheckForNull
ValueEntry<K, V> toRemove;
{
this.nextEntry = ValueSet.this.firstEntry;
this.expectedModCount = ValueSet.this.modCount;
}
private void checkForComodification() {
if (ValueSet.this.modCount != this.expectedModCount) {
throw new ConcurrentModificationException();
}
}
public boolean hasNext() {
checkForComodification();
return this.nextEntry != ValueSet.this;
}
@ParametricNullness
public V next() {
if (hasNext()) {
ValueEntry<K, V> valueEntry = (ValueEntry) this.nextEntry;
V value = valueEntry.getValue();
this.toRemove = valueEntry;
this.nextEntry = valueEntry.getSuccessorInValueSet();
return value;
}
throw new NoSuchElementException();
}
public void remove() {
checkForComodification();
Preconditions.checkState(this.toRemove != null, "no calls to next() since the last call to remove()");
ValueSet.this.remove(this.toRemove.getValue());
this.expectedModCount = ValueSet.this.modCount;
this.toRemove = null;
}
};
}
public int size() {
return this.size;
}
public boolean contains(@CheckForNull Object obj) {
int smearedHash = Hashing.smearedHash(obj);
for (ValueEntry<K, V> valueEntry = this.hashTable[mask() & smearedHash]; valueEntry != null; valueEntry = valueEntry.nextInValueBucket) {
if (valueEntry.matchesValue(obj, smearedHash)) {
return true;
}
}
return false;
}
public boolean add(@ParametricNullness V v) {
int smearedHash = Hashing.smearedHash(v);
int mask = mask() & smearedHash;
ValueEntry<K, V> valueEntry = this.hashTable[mask];
for (ValueEntry<K, V> valueEntry2 = valueEntry; valueEntry2 != null; valueEntry2 = valueEntry2.nextInValueBucket) {
if (valueEntry2.matchesValue(v, smearedHash)) {
return false;
}
}
ValueEntry<K, V> valueEntry3 = new ValueEntry<>(this.key, v, smearedHash, valueEntry);
LinkedHashMultimap.succeedsInValueSet(this.lastEntry, valueEntry3);
LinkedHashMultimap.succeedsInValueSet(valueEntry3, this);
LinkedHashMultimap.succeedsInMultimap(LinkedHashMultimap.this.multimapHeaderEntry.getPredecessorInMultimap(), valueEntry3);
LinkedHashMultimap.succeedsInMultimap(valueEntry3, LinkedHashMultimap.this.multimapHeaderEntry);
this.hashTable[mask] = valueEntry3;
this.size++;
this.modCount++;
rehashIfNecessary();
return true;
}
private void rehashIfNecessary() {
if (Hashing.needsResizing(this.size, this.hashTable.length, LinkedHashMultimap.VALUE_SET_LOAD_FACTOR)) {
int length = this.hashTable.length * 2;
ValueEntry<K, V>[] valueEntryArr = new ValueEntry[length];
this.hashTable = valueEntryArr;
int i = length - 1;
for (ValueSetLink valueSetLink = this.firstEntry; valueSetLink != this; valueSetLink = valueSetLink.getSuccessorInValueSet()) {
ValueEntry<K, V> valueEntry = (ValueEntry) valueSetLink;
int i2 = valueEntry.smearedValueHash & i;
valueEntry.nextInValueBucket = valueEntryArr[i2];
valueEntryArr[i2] = valueEntry;
}
}
}
public boolean remove(@CheckForNull Object obj) {
int smearedHash = Hashing.smearedHash(obj);
int mask = mask() & smearedHash;
ValueEntry<K, V> valueEntry = null;
for (ValueEntry<K, V> valueEntry2 = this.hashTable[mask]; valueEntry2 != null; valueEntry2 = valueEntry2.nextInValueBucket) {
if (valueEntry2.matchesValue(obj, smearedHash)) {
if (valueEntry == null) {
this.hashTable[mask] = valueEntry2.nextInValueBucket;
} else {
valueEntry.nextInValueBucket = valueEntry2.nextInValueBucket;
}
LinkedHashMultimap.deleteFromValueSet(valueEntry2);
LinkedHashMultimap.deleteFromMultimap(valueEntry2);
this.size--;
this.modCount++;
return true;
}
valueEntry = valueEntry2;
}
return false;
}
public void clear() {
Arrays.fill(this.hashTable, (Object) null);
this.size = 0;
for (ValueSetLink<K, V> valueSetLink = this.firstEntry; valueSetLink != this; valueSetLink = valueSetLink.getSuccessorInValueSet()) {
LinkedHashMultimap.deleteFromMultimap((ValueEntry) valueSetLink);
}
LinkedHashMultimap.succeedsInValueSet(this, this);
this.modCount++;
}
}
/* access modifiers changed from: package-private */
public Iterator<Map.Entry<K, V>> entryIterator() {
return new Iterator<Map.Entry<K, V>>() {
ValueEntry<K, V> nextEntry;
@CheckForNull
ValueEntry<K, V> toRemove;
{
this.nextEntry = LinkedHashMultimap.this.multimapHeaderEntry.getSuccessorInMultimap();
}
public boolean hasNext() {
return this.nextEntry != LinkedHashMultimap.this.multimapHeaderEntry;
}
public Map.Entry<K, V> next() {
if (hasNext()) {
ValueEntry<K, V> valueEntry = this.nextEntry;
this.toRemove = valueEntry;
this.nextEntry = valueEntry.getSuccessorInMultimap();
return valueEntry;
}
throw new NoSuchElementException();
}
public void remove() {
Preconditions.checkState(this.toRemove != null, "no calls to next() since the last call to remove()");
LinkedHashMultimap.this.remove(this.toRemove.getKey(), this.toRemove.getValue());
this.toRemove = null;
}
};
}
/* access modifiers changed from: package-private */
public Iterator<V> valueIterator() {
return Maps.valueIterator(entryIterator());
}
public void clear() {
super.clear();
ValueEntry<K, V> valueEntry = this.multimapHeaderEntry;
succeedsInMultimap(valueEntry, valueEntry);
}
private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
objectOutputStream.defaultWriteObject();
objectOutputStream.writeInt(keySet().size());
for (Object writeObject : keySet()) {
objectOutputStream.writeObject(writeObject);
}
objectOutputStream.writeInt(size());
for (Map.Entry entry : entries()) {
objectOutputStream.writeObject(entry.getKey());
objectOutputStream.writeObject(entry.getValue());
}
}
private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
objectInputStream.defaultReadObject();
ValueEntry<K, V> newHeader = ValueEntry.newHeader();
this.multimapHeaderEntry = newHeader;
succeedsInMultimap(newHeader, newHeader);
this.valueSetCapacity = 2;
int readInt = objectInputStream.readInt();
Map newLinkedHashMapWithExpectedSize = Platform.newLinkedHashMapWithExpectedSize(12);
for (int i = 0; i < readInt; i++) {
Object readObject = objectInputStream.readObject();
newLinkedHashMapWithExpectedSize.put(readObject, createCollection(readObject));
}
int readInt2 = objectInputStream.readInt();
for (int i2 = 0; i2 < readInt2; i2++) {
Object readObject2 = objectInputStream.readObject();
Object readObject3 = objectInputStream.readObject();
Collection collection = (Collection) newLinkedHashMapWithExpectedSize.get(readObject2);
java.util.Objects.requireNonNull(collection);
Collection collection2 = collection;
collection.add(readObject3);
}
setMap(newLinkedHashMapWithExpectedSize);
}
}
Download file