CrackMe.apk
Download file
package com.google.common.primitives;
import com.facebook.react.uimanager.events.TouchesHelper;
import com.google.common.base.Converter;
import com.google.common.base.Preconditions;
import java.io.Serializable;
import java.util.AbstractList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.RandomAccess;
import javax.annotation.CheckForNull;
@ElementTypesAreNonnullByDefault
public final class Longs {
public static final int BYTES = 8;
public static final long MAX_POWER_OF_TWO = 4611686018427387904L;
public static int compare(long j, long j2) {
int i = (j > j2 ? 1 : (j == j2 ? 0 : -1));
if (i < 0) {
return -1;
}
return i > 0 ? 1 : 0;
}
public static long fromBytes(byte b, byte b2, byte b3, byte b4, byte b5, byte b6, byte b7, byte b8) {
return ((((long) b2) & 255) << 48) | ((((long) b) & 255) << 56) | ((((long) b3) & 255) << 40) | ((((long) b4) & 255) << 32) | ((((long) b5) & 255) << 24) | ((((long) b6) & 255) << 16) | ((((long) b7) & 255) << 8) | (((long) b8) & 255);
}
public static int hashCode(long j) {
return (int) (j ^ (j >>> 32));
}
private Longs() {
}
public static boolean contains(long[] jArr, long j) {
for (long j2 : jArr) {
if (j2 == j) {
return true;
}
}
return false;
}
public static int indexOf(long[] jArr, long j) {
return indexOf(jArr, j, 0, jArr.length);
}
/* access modifiers changed from: private */
public static int indexOf(long[] jArr, long j, int i, int i2) {
while (i < i2) {
if (jArr[i] == j) {
return i;
}
i++;
}
return -1;
}
public static int indexOf(long[] jArr, long[] jArr2) {
Preconditions.checkNotNull(jArr, "array");
Preconditions.checkNotNull(jArr2, TouchesHelper.TARGET_KEY);
if (jArr2.length == 0) {
return 0;
}
int i = 0;
while (i < (jArr.length - jArr2.length) + 1) {
int i2 = 0;
while (i2 < jArr2.length) {
if (jArr[i + i2] != jArr2[i2]) {
i++;
} else {
i2++;
}
}
return i;
}
return -1;
}
public static int lastIndexOf(long[] jArr, long j) {
return lastIndexOf(jArr, j, 0, jArr.length);
}
/* access modifiers changed from: private */
public static int lastIndexOf(long[] jArr, long j, int i, int i2) {
for (int i3 = i2 - 1; i3 >= i; i3--) {
if (jArr[i3] == j) {
return i3;
}
}
return -1;
}
public static long min(long... jArr) {
Preconditions.checkArgument(jArr.length > 0);
long j = jArr[0];
for (int i = 1; i < jArr.length; i++) {
if (jArr[i] < j) {
j = jArr[i];
}
}
return j;
}
public static long max(long... jArr) {
Preconditions.checkArgument(jArr.length > 0);
long j = jArr[0];
for (int i = 1; i < jArr.length; i++) {
if (jArr[i] > j) {
j = jArr[i];
}
}
return j;
}
public static long constrainToRange(long j, long j2, long j3) {
Preconditions.checkArgument(j2 <= j3, "min (%s) must be less than or equal to max (%s)", j2, j3);
return Math.min(Math.max(j, j2), j3);
}
public static long[] concat(long[]... jArr) {
int i = 0;
for (long[] length : jArr) {
i += length.length;
}
long[] jArr2 = new long[i];
int i2 = 0;
for (long[] jArr3 : jArr) {
System.arraycopy(jArr3, 0, jArr2, i2, jArr3.length);
i2 += jArr3.length;
}
return jArr2;
}
public static byte[] toByteArray(long j) {
byte[] bArr = new byte[8];
for (int i = 7; i >= 0; i--) {
bArr[i] = (byte) ((int) (255 & j));
j >>= 8;
}
return bArr;
}
public static long fromByteArray(byte[] bArr) {
Preconditions.checkArgument(bArr.length >= 8, "array too small: %s < %s", bArr.length, 8);
return fromBytes(bArr[0], bArr[1], bArr[2], bArr[3], bArr[4], bArr[5], bArr[6], bArr[7]);
}
static final class AsciiDigits {
private static final byte[] asciiDigits;
private AsciiDigits() {
}
static {
byte[] bArr = new byte[128];
Arrays.fill(bArr, (byte) -1);
for (int i = 0; i < 10; i++) {
bArr[i + 48] = (byte) i;
}
for (int i2 = 0; i2 < 26; i2++) {
byte b = (byte) (i2 + 10);
bArr[i2 + 65] = b;
bArr[i2 + 97] = b;
}
asciiDigits = bArr;
}
static int digit(char c) {
if (c < 128) {
return asciiDigits[c];
}
return -1;
}
}
@CheckForNull
public static Long tryParse(String str) {
return tryParse(str, 10);
}
@CheckForNull
public static Long tryParse(String str, int i) {
String str2 = str;
int i2 = i;
if (((String) Preconditions.checkNotNull(str)).isEmpty()) {
return null;
}
if (i2 < 2 || i2 > 36) {
StringBuilder sb = new StringBuilder(65);
sb.append("radix must be between MIN_RADIX and MAX_RADIX but was ");
sb.append(i2);
throw new IllegalArgumentException(sb.toString());
}
int i3 = 0;
if (str2.charAt(0) == '-') {
i3 = 1;
}
if (i3 == str.length()) {
return null;
}
int i4 = i3 + 1;
int digit = AsciiDigits.digit(str2.charAt(i3));
if (digit < 0 || digit >= i2) {
return null;
}
long j = (long) (-digit);
long j2 = (long) i2;
long j3 = Long.MIN_VALUE / j2;
while (i4 < str.length()) {
int i5 = i4 + 1;
int digit2 = AsciiDigits.digit(str2.charAt(i4));
if (digit2 < 0 || digit2 >= i2 || j < j3) {
return null;
}
long j4 = j * j2;
long j5 = (long) digit2;
if (j4 < j5 - Long.MIN_VALUE) {
return null;
}
j = j4 - j5;
i4 = i5;
}
if (i3 != 0) {
return Long.valueOf(j);
}
if (j == Long.MIN_VALUE) {
return null;
}
return Long.valueOf(-j);
}
private static final class LongConverter extends Converter<String, Long> implements Serializable {
static final LongConverter INSTANCE = new LongConverter();
private static final long serialVersionUID = 1;
public String toString() {
return "Longs.stringConverter()";
}
private LongConverter() {
}
/* access modifiers changed from: protected */
public Long doForward(String str) {
return Long.decode(str);
}
/* access modifiers changed from: protected */
public String doBackward(Long l) {
return l.toString();
}
private Object readResolve() {
return INSTANCE;
}
}
public static Converter<String, Long> stringConverter() {
return LongConverter.INSTANCE;
}
public static long[] ensureCapacity(long[] jArr, int i, int i2) {
boolean z = true;
Preconditions.checkArgument(i >= 0, "Invalid minLength: %s", i);
if (i2 < 0) {
z = false;
}
Preconditions.checkArgument(z, "Invalid padding: %s", i2);
return jArr.length < i ? Arrays.copyOf(jArr, i + i2) : jArr;
}
public static String join(String str, long... jArr) {
Preconditions.checkNotNull(str);
if (jArr.length == 0) {
return "";
}
StringBuilder sb = new StringBuilder(jArr.length * 10);
sb.append(jArr[0]);
for (int i = 1; i < jArr.length; i++) {
sb.append(str);
sb.append(jArr[i]);
}
return sb.toString();
}
public static Comparator<long[]> lexicographicalComparator() {
return LexicographicalComparator.INSTANCE;
}
private enum LexicographicalComparator implements Comparator<long[]> {
INSTANCE;
public String toString() {
return "Longs.lexicographicalComparator()";
}
public int compare(long[] jArr, long[] jArr2) {
int min = Math.min(jArr.length, jArr2.length);
for (int i = 0; i < min; i++) {
int compare = Longs.compare(jArr[i], jArr2[i]);
if (compare != 0) {
return compare;
}
}
return jArr.length - jArr2.length;
}
}
public static void sortDescending(long[] jArr) {
Preconditions.checkNotNull(jArr);
sortDescending(jArr, 0, jArr.length);
}
public static void sortDescending(long[] jArr, int i, int i2) {
Preconditions.checkNotNull(jArr);
Preconditions.checkPositionIndexes(i, i2, jArr.length);
Arrays.sort(jArr, i, i2);
reverse(jArr, i, i2);
}
public static void reverse(long[] jArr) {
Preconditions.checkNotNull(jArr);
reverse(jArr, 0, jArr.length);
}
public static void reverse(long[] jArr, int i, int i2) {
Preconditions.checkNotNull(jArr);
Preconditions.checkPositionIndexes(i, i2, jArr.length);
for (int i3 = i2 - 1; i < i3; i3--) {
long j = jArr[i];
jArr[i] = jArr[i3];
jArr[i3] = j;
i++;
}
}
public static long[] toArray(Collection<? extends Number> collection) {
if (collection instanceof LongArrayAsList) {
return ((LongArrayAsList) collection).toLongArray();
}
Object[] array = collection.toArray();
int length = array.length;
long[] jArr = new long[length];
for (int i = 0; i < length; i++) {
jArr[i] = ((Number) Preconditions.checkNotNull(array[i])).longValue();
}
return jArr;
}
public static List<Long> asList(long... jArr) {
if (jArr.length == 0) {
return Collections.emptyList();
}
return new LongArrayAsList(jArr);
}
private static class LongArrayAsList extends AbstractList<Long> implements RandomAccess, Serializable {
private static final long serialVersionUID = 0;
final long[] array;
final int end;
final int start;
public boolean isEmpty() {
return false;
}
LongArrayAsList(long[] jArr) {
this(jArr, 0, jArr.length);
}
LongArrayAsList(long[] jArr, int i, int i2) {
this.array = jArr;
this.start = i;
this.end = i2;
}
public int size() {
return this.end - this.start;
}
public Long get(int i) {
Preconditions.checkElementIndex(i, size());
return Long.valueOf(this.array[this.start + i]);
}
public boolean contains(@CheckForNull Object obj) {
return (obj instanceof Long) && Longs.indexOf(this.array, ((Long) obj).longValue(), this.start, this.end) != -1;
}
public int indexOf(@CheckForNull Object obj) {
int access$000;
if (!(obj instanceof Long) || (access$000 = Longs.indexOf(this.array, ((Long) obj).longValue(), this.start, this.end)) < 0) {
return -1;
}
return access$000 - this.start;
}
public int lastIndexOf(@CheckForNull Object obj) {
int access$100;
if (!(obj instanceof Long) || (access$100 = Longs.lastIndexOf(this.array, ((Long) obj).longValue(), this.start, this.end)) < 0) {
return -1;
}
return access$100 - this.start;
}
public Long set(int i, Long l) {
Preconditions.checkElementIndex(i, size());
long[] jArr = this.array;
int i2 = this.start;
long j = jArr[i2 + i];
jArr[i2 + i] = ((Long) Preconditions.checkNotNull(l)).longValue();
return Long.valueOf(j);
}
public List<Long> subList(int i, int i2) {
Preconditions.checkPositionIndexes(i, i2, size());
if (i == i2) {
return Collections.emptyList();
}
long[] jArr = this.array;
int i3 = this.start;
return new LongArrayAsList(jArr, i + i3, i3 + i2);
}
public boolean equals(@CheckForNull Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof LongArrayAsList)) {
return super.equals(obj);
}
LongArrayAsList longArrayAsList = (LongArrayAsList) obj;
int size = size();
if (longArrayAsList.size() != size) {
return false;
}
for (int i = 0; i < size; i++) {
if (this.array[this.start + i] != longArrayAsList.array[longArrayAsList.start + i]) {
return false;
}
}
return true;
}
public int hashCode() {
int i = 1;
for (int i2 = this.start; i2 < this.end; i2++) {
i = (i * 31) + Longs.hashCode(this.array[i2]);
}
return i;
}
public String toString() {
StringBuilder sb = new StringBuilder(size() * 10);
sb.append('[');
sb.append(this.array[this.start]);
int i = this.start;
while (true) {
i++;
if (i < this.end) {
sb.append(", ");
sb.append(this.array[i]);
} else {
sb.append(']');
return sb.toString();
}
}
}
/* access modifiers changed from: package-private */
public long[] toLongArray() {
return Arrays.copyOfRange(this.array, this.start, this.end);
}
}
}
Download file