CrackMe.apk
Download file
package com.google.common.primitives;
import com.facebook.react.uimanager.events.TouchesHelper;
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.List;
import java.util.RandomAccess;
import javax.annotation.CheckForNull;
@ElementTypesAreNonnullByDefault
public final class Bytes {
public static int hashCode(byte b) {
return b;
}
private Bytes() {
}
public static boolean contains(byte[] bArr, byte b) {
for (byte b2 : bArr) {
if (b2 == b) {
return true;
}
}
return false;
}
public static int indexOf(byte[] bArr, byte b) {
return indexOf(bArr, b, 0, bArr.length);
}
/* access modifiers changed from: private */
public static int indexOf(byte[] bArr, byte b, int i, int i2) {
while (i < i2) {
if (bArr[i] == b) {
return i;
}
i++;
}
return -1;
}
public static int indexOf(byte[] bArr, byte[] bArr2) {
Preconditions.checkNotNull(bArr, "array");
Preconditions.checkNotNull(bArr2, TouchesHelper.TARGET_KEY);
if (bArr2.length == 0) {
return 0;
}
int i = 0;
while (i < (bArr.length - bArr2.length) + 1) {
int i2 = 0;
while (i2 < bArr2.length) {
if (bArr[i + i2] != bArr2[i2]) {
i++;
} else {
i2++;
}
}
return i;
}
return -1;
}
public static int lastIndexOf(byte[] bArr, byte b) {
return lastIndexOf(bArr, b, 0, bArr.length);
}
/* access modifiers changed from: private */
public static int lastIndexOf(byte[] bArr, byte b, int i, int i2) {
for (int i3 = i2 - 1; i3 >= i; i3--) {
if (bArr[i3] == b) {
return i3;
}
}
return -1;
}
public static byte[] concat(byte[]... bArr) {
int i = 0;
for (byte[] length : bArr) {
i += length.length;
}
byte[] bArr2 = new byte[i];
int i2 = 0;
for (byte[] bArr3 : bArr) {
System.arraycopy(bArr3, 0, bArr2, i2, bArr3.length);
i2 += bArr3.length;
}
return bArr2;
}
public static byte[] ensureCapacity(byte[] bArr, 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 bArr.length < i ? Arrays.copyOf(bArr, i + i2) : bArr;
}
public static byte[] toArray(Collection<? extends Number> collection) {
if (collection instanceof ByteArrayAsList) {
return ((ByteArrayAsList) collection).toByteArray();
}
Object[] array = collection.toArray();
int length = array.length;
byte[] bArr = new byte[length];
for (int i = 0; i < length; i++) {
bArr[i] = ((Number) Preconditions.checkNotNull(array[i])).byteValue();
}
return bArr;
}
public static List<Byte> asList(byte... bArr) {
if (bArr.length == 0) {
return Collections.emptyList();
}
return new ByteArrayAsList(bArr);
}
private static class ByteArrayAsList extends AbstractList<Byte> implements RandomAccess, Serializable {
private static final long serialVersionUID = 0;
final byte[] array;
final int end;
final int start;
public boolean isEmpty() {
return false;
}
ByteArrayAsList(byte[] bArr) {
this(bArr, 0, bArr.length);
}
ByteArrayAsList(byte[] bArr, int i, int i2) {
this.array = bArr;
this.start = i;
this.end = i2;
}
public int size() {
return this.end - this.start;
}
public Byte get(int i) {
Preconditions.checkElementIndex(i, size());
return Byte.valueOf(this.array[this.start + i]);
}
public boolean contains(@CheckForNull Object obj) {
return (obj instanceof Byte) && Bytes.indexOf(this.array, ((Byte) obj).byteValue(), this.start, this.end) != -1;
}
public int indexOf(@CheckForNull Object obj) {
int access$000;
if (!(obj instanceof Byte) || (access$000 = Bytes.indexOf(this.array, ((Byte) obj).byteValue(), this.start, this.end)) < 0) {
return -1;
}
return access$000 - this.start;
}
public int lastIndexOf(@CheckForNull Object obj) {
int access$100;
if (!(obj instanceof Byte) || (access$100 = Bytes.lastIndexOf(this.array, ((Byte) obj).byteValue(), this.start, this.end)) < 0) {
return -1;
}
return access$100 - this.start;
}
public Byte set(int i, Byte b) {
Preconditions.checkElementIndex(i, size());
byte[] bArr = this.array;
int i2 = this.start;
byte b2 = bArr[i2 + i];
bArr[i2 + i] = ((Byte) Preconditions.checkNotNull(b)).byteValue();
return Byte.valueOf(b2);
}
public List<Byte> subList(int i, int i2) {
Preconditions.checkPositionIndexes(i, i2, size());
if (i == i2) {
return Collections.emptyList();
}
byte[] bArr = this.array;
int i3 = this.start;
return new ByteArrayAsList(bArr, i + i3, i3 + i2);
}
public boolean equals(@CheckForNull Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ByteArrayAsList)) {
return super.equals(obj);
}
ByteArrayAsList byteArrayAsList = (ByteArrayAsList) obj;
int size = size();
if (byteArrayAsList.size() != size) {
return false;
}
for (int i = 0; i < size; i++) {
if (this.array[this.start + i] != byteArrayAsList.array[byteArrayAsList.start + i]) {
return false;
}
}
return true;
}
public int hashCode() {
int i = 1;
for (int i2 = this.start; i2 < this.end; i2++) {
i = (i * 31) + Bytes.hashCode(this.array[i2]);
}
return i;
}
public String toString() {
StringBuilder sb = new StringBuilder(size() * 5);
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 byte[] toByteArray() {
return Arrays.copyOfRange(this.array, this.start, this.end);
}
}
public static void reverse(byte[] bArr) {
Preconditions.checkNotNull(bArr);
reverse(bArr, 0, bArr.length);
}
public static void reverse(byte[] bArr, int i, int i2) {
Preconditions.checkNotNull(bArr);
Preconditions.checkPositionIndexes(i, i2, bArr.length);
for (int i3 = i2 - 1; i < i3; i3--) {
byte b = bArr[i];
bArr[i] = bArr[i3];
bArr[i3] = b;
i++;
}
}
}
Download file