CrackMe.apk
Download file
package com.google.common.math;
import com.google.common.base.Preconditions;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.List;
@ElementTypesAreNonnullByDefault
public final class BigIntegerMath {
private static final double LN_10 = Math.log(10.0d);
private static final double LN_2 = Math.log(2.0d);
static final BigInteger SQRT2_PRECOMPUTED_BITS = new BigInteger("16a09e667f3bcc908b2fb1366ea957d3e3adec17512775099da2f590b0667322a", 16);
static final int SQRT2_PRECOMPUTE_THRESHOLD = 256;
public static BigInteger ceilingPowerOfTwo(BigInteger bigInteger) {
return BigInteger.ZERO.setBit(log2(bigInteger, RoundingMode.CEILING));
}
public static BigInteger floorPowerOfTwo(BigInteger bigInteger) {
return BigInteger.ZERO.setBit(log2(bigInteger, RoundingMode.FLOOR));
}
public static boolean isPowerOfTwo(BigInteger bigInteger) {
Preconditions.checkNotNull(bigInteger);
return bigInteger.signum() > 0 && bigInteger.getLowestSetBit() == bigInteger.bitLength() - 1;
}
public static int log2(BigInteger bigInteger, RoundingMode roundingMode) {
MathPreconditions.checkPositive("x", (BigInteger) Preconditions.checkNotNull(bigInteger));
int bitLength = bigInteger.bitLength() - 1;
switch (AnonymousClass1.$SwitchMap$java$math$RoundingMode[roundingMode.ordinal()]) {
case 1:
MathPreconditions.checkRoundingUnnecessary(isPowerOfTwo(bigInteger));
break;
case 2:
case 3:
break;
case 4:
case 5:
return isPowerOfTwo(bigInteger) ? bitLength : bitLength + 1;
case 6:
case 7:
case 8:
return bitLength < 256 ? bigInteger.compareTo(SQRT2_PRECOMPUTED_BITS.shiftRight(256 - bitLength)) <= 0 ? bitLength : bitLength + 1 : bigInteger.pow(2).bitLength() + -1 < (bitLength * 2) + 1 ? bitLength : bitLength + 1;
default:
throw new AssertionError();
}
return bitLength;
}
/* renamed from: com.google.common.math.BigIntegerMath$1 reason: invalid class name */
static /* synthetic */ class AnonymousClass1 {
static final /* synthetic */ int[] $SwitchMap$java$math$RoundingMode;
/* JADX WARNING: Can't wrap try/catch for region: R(18:0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|18) */
/* JADX WARNING: Code restructure failed: missing block: B:19:?, code lost:
return;
*/
/* JADX WARNING: Failed to process nested try/catch */
/* JADX WARNING: Missing exception handler attribute for start block: B:11:0x003e */
/* JADX WARNING: Missing exception handler attribute for start block: B:13:0x0049 */
/* JADX WARNING: Missing exception handler attribute for start block: B:15:0x0054 */
/* JADX WARNING: Missing exception handler attribute for start block: B:3:0x0012 */
/* JADX WARNING: Missing exception handler attribute for start block: B:5:0x001d */
/* JADX WARNING: Missing exception handler attribute for start block: B:7:0x0028 */
/* JADX WARNING: Missing exception handler attribute for start block: B:9:0x0033 */
static {
/*
java.math.RoundingMode[] r0 = java.math.RoundingMode.values()
int r0 = r0.length
int[] r0 = new int[r0]
$SwitchMap$java$math$RoundingMode = r0
java.math.RoundingMode r1 = java.math.RoundingMode.UNNECESSARY // Catch:{ NoSuchFieldError -> 0x0012 }
int r1 = r1.ordinal() // Catch:{ NoSuchFieldError -> 0x0012 }
r2 = 1
r0[r1] = r2 // Catch:{ NoSuchFieldError -> 0x0012 }
L_0x0012:
int[] r0 = $SwitchMap$java$math$RoundingMode // Catch:{ NoSuchFieldError -> 0x001d }
java.math.RoundingMode r1 = java.math.RoundingMode.DOWN // Catch:{ NoSuchFieldError -> 0x001d }
int r1 = r1.ordinal() // Catch:{ NoSuchFieldError -> 0x001d }
r2 = 2
r0[r1] = r2 // Catch:{ NoSuchFieldError -> 0x001d }
L_0x001d:
int[] r0 = $SwitchMap$java$math$RoundingMode // Catch:{ NoSuchFieldError -> 0x0028 }
java.math.RoundingMode r1 = java.math.RoundingMode.FLOOR // Catch:{ NoSuchFieldError -> 0x0028 }
int r1 = r1.ordinal() // Catch:{ NoSuchFieldError -> 0x0028 }
r2 = 3
r0[r1] = r2 // Catch:{ NoSuchFieldError -> 0x0028 }
L_0x0028:
int[] r0 = $SwitchMap$java$math$RoundingMode // Catch:{ NoSuchFieldError -> 0x0033 }
java.math.RoundingMode r1 = java.math.RoundingMode.UP // Catch:{ NoSuchFieldError -> 0x0033 }
int r1 = r1.ordinal() // Catch:{ NoSuchFieldError -> 0x0033 }
r2 = 4
r0[r1] = r2 // Catch:{ NoSuchFieldError -> 0x0033 }
L_0x0033:
int[] r0 = $SwitchMap$java$math$RoundingMode // Catch:{ NoSuchFieldError -> 0x003e }
java.math.RoundingMode r1 = java.math.RoundingMode.CEILING // Catch:{ NoSuchFieldError -> 0x003e }
int r1 = r1.ordinal() // Catch:{ NoSuchFieldError -> 0x003e }
r2 = 5
r0[r1] = r2 // Catch:{ NoSuchFieldError -> 0x003e }
L_0x003e:
int[] r0 = $SwitchMap$java$math$RoundingMode // Catch:{ NoSuchFieldError -> 0x0049 }
java.math.RoundingMode r1 = java.math.RoundingMode.HALF_DOWN // Catch:{ NoSuchFieldError -> 0x0049 }
int r1 = r1.ordinal() // Catch:{ NoSuchFieldError -> 0x0049 }
r2 = 6
r0[r1] = r2 // Catch:{ NoSuchFieldError -> 0x0049 }
L_0x0049:
int[] r0 = $SwitchMap$java$math$RoundingMode // Catch:{ NoSuchFieldError -> 0x0054 }
java.math.RoundingMode r1 = java.math.RoundingMode.HALF_UP // Catch:{ NoSuchFieldError -> 0x0054 }
int r1 = r1.ordinal() // Catch:{ NoSuchFieldError -> 0x0054 }
r2 = 7
r0[r1] = r2 // Catch:{ NoSuchFieldError -> 0x0054 }
L_0x0054:
int[] r0 = $SwitchMap$java$math$RoundingMode // Catch:{ NoSuchFieldError -> 0x0060 }
java.math.RoundingMode r1 = java.math.RoundingMode.HALF_EVEN // Catch:{ NoSuchFieldError -> 0x0060 }
int r1 = r1.ordinal() // Catch:{ NoSuchFieldError -> 0x0060 }
r2 = 8
r0[r1] = r2 // Catch:{ NoSuchFieldError -> 0x0060 }
L_0x0060:
return
*/
throw new UnsupportedOperationException("Method not decompiled: com.google.common.math.BigIntegerMath.AnonymousClass1.<clinit>():void");
}
}
public static int log10(BigInteger bigInteger, RoundingMode roundingMode) {
int i;
MathPreconditions.checkPositive("x", bigInteger);
if (fitsInLong(bigInteger)) {
return LongMath.log10(bigInteger.longValue(), roundingMode);
}
int log2 = (int) ((((double) log2(bigInteger, RoundingMode.FLOOR)) * LN_2) / LN_10);
BigInteger pow = BigInteger.TEN.pow(log2);
int compareTo = pow.compareTo(bigInteger);
if (compareTo > 0) {
do {
log2--;
pow = pow.divide(BigInteger.TEN);
i = pow.compareTo(bigInteger);
} while (i > 0);
} else {
BigInteger multiply = BigInteger.TEN.multiply(pow);
int i2 = compareTo;
int compareTo2 = multiply.compareTo(bigInteger);
while (compareTo2 <= 0) {
log2++;
BigInteger multiply2 = BigInteger.TEN.multiply(multiply);
int compareTo3 = multiply2.compareTo(bigInteger);
BigInteger bigInteger2 = multiply;
multiply = multiply2;
pow = bigInteger2;
int i3 = compareTo3;
i2 = compareTo2;
compareTo2 = i3;
}
i = i2;
}
switch (AnonymousClass1.$SwitchMap$java$math$RoundingMode[roundingMode.ordinal()]) {
case 1:
MathPreconditions.checkRoundingUnnecessary(i == 0);
break;
case 2:
case 3:
break;
case 4:
case 5:
return pow.equals(bigInteger) ? log2 : log2 + 1;
case 6:
case 7:
case 8:
return bigInteger.pow(2).compareTo(pow.pow(2).multiply(BigInteger.TEN)) <= 0 ? log2 : log2 + 1;
default:
throw new AssertionError();
}
return log2;
}
public static BigInteger sqrt(BigInteger bigInteger, RoundingMode roundingMode) {
MathPreconditions.checkNonNegative("x", bigInteger);
if (fitsInLong(bigInteger)) {
return BigInteger.valueOf(LongMath.sqrt(bigInteger.longValue(), roundingMode));
}
BigInteger sqrtFloor = sqrtFloor(bigInteger);
switch (AnonymousClass1.$SwitchMap$java$math$RoundingMode[roundingMode.ordinal()]) {
case 1:
MathPreconditions.checkRoundingUnnecessary(sqrtFloor.pow(2).equals(bigInteger));
break;
case 2:
case 3:
break;
case 4:
case 5:
int intValue = sqrtFloor.intValue();
return intValue * intValue == bigInteger.intValue() && sqrtFloor.pow(2).equals(bigInteger) ? sqrtFloor : sqrtFloor.add(BigInteger.ONE);
case 6:
case 7:
case 8:
return sqrtFloor.pow(2).add(sqrtFloor).compareTo(bigInteger) >= 0 ? sqrtFloor : sqrtFloor.add(BigInteger.ONE);
default:
throw new AssertionError();
}
return sqrtFloor;
}
private static BigInteger sqrtFloor(BigInteger bigInteger) {
BigInteger bigInteger2;
int log2 = log2(bigInteger, RoundingMode.FLOOR);
if (log2 < 1023) {
bigInteger2 = sqrtApproxWithDoubles(bigInteger);
} else {
int i = (log2 - 52) & -2;
bigInteger2 = sqrtApproxWithDoubles(bigInteger.shiftRight(i)).shiftLeft(i >> 1);
}
BigInteger shiftRight = bigInteger2.add(bigInteger.divide(bigInteger2)).shiftRight(1);
if (bigInteger2.equals(shiftRight)) {
return bigInteger2;
}
while (true) {
BigInteger shiftRight2 = shiftRight.add(bigInteger.divide(shiftRight)).shiftRight(1);
if (shiftRight2.compareTo(shiftRight) >= 0) {
return shiftRight;
}
shiftRight = shiftRight2;
}
}
private static BigInteger sqrtApproxWithDoubles(BigInteger bigInteger) {
return DoubleMath.roundToBigInteger(Math.sqrt(DoubleUtils.bigToDouble(bigInteger)), RoundingMode.HALF_EVEN);
}
public static double roundToDouble(BigInteger bigInteger, RoundingMode roundingMode) {
return BigIntegerToDoubleRounder.INSTANCE.roundToDouble(bigInteger, roundingMode);
}
private static class BigIntegerToDoubleRounder extends ToDoubleRounder<BigInteger> {
static final BigIntegerToDoubleRounder INSTANCE = new BigIntegerToDoubleRounder();
private BigIntegerToDoubleRounder() {
}
/* access modifiers changed from: package-private */
public double roundToDoubleArbitrarily(BigInteger bigInteger) {
return DoubleUtils.bigToDouble(bigInteger);
}
/* access modifiers changed from: package-private */
public int sign(BigInteger bigInteger) {
return bigInteger.signum();
}
/* access modifiers changed from: package-private */
public BigInteger toX(double d, RoundingMode roundingMode) {
return DoubleMath.roundToBigInteger(d, roundingMode);
}
/* access modifiers changed from: package-private */
public BigInteger minus(BigInteger bigInteger, BigInteger bigInteger2) {
return bigInteger.subtract(bigInteger2);
}
}
public static BigInteger divide(BigInteger bigInteger, BigInteger bigInteger2, RoundingMode roundingMode) {
return new BigDecimal(bigInteger).divide(new BigDecimal(bigInteger2), 0, roundingMode).toBigIntegerExact();
}
public static BigInteger factorial(int i) {
int i2 = i;
MathPreconditions.checkNonNegative("n", i2);
if (i2 < LongMath.factorials.length) {
return BigInteger.valueOf(LongMath.factorials[i2]);
}
ArrayList arrayList = new ArrayList(IntMath.divide(IntMath.log2(i2, RoundingMode.CEILING) * i2, 64, RoundingMode.CEILING));
int length = LongMath.factorials.length;
long j = LongMath.factorials[length - 1];
int numberOfTrailingZeros = Long.numberOfTrailingZeros(j);
long j2 = j >> numberOfTrailingZeros;
int log2 = LongMath.log2(j2, RoundingMode.FLOOR) + 1;
long j3 = (long) length;
int log22 = LongMath.log2(j3, RoundingMode.FLOOR) + 1;
int i3 = 1 << (log22 - 1);
while (j3 <= ((long) i2)) {
if ((((long) i3) & j3) != 0) {
i3 <<= 1;
log22++;
}
int numberOfTrailingZeros2 = Long.numberOfTrailingZeros(j3);
long j4 = j3 >> numberOfTrailingZeros2;
numberOfTrailingZeros += numberOfTrailingZeros2;
if ((log22 - numberOfTrailingZeros2) + log2 >= 64) {
arrayList.add(BigInteger.valueOf(j2));
j2 = 1;
}
j2 *= j4;
log2 = LongMath.log2(j2, RoundingMode.FLOOR) + 1;
j3++;
}
if (j2 > 1) {
arrayList.add(BigInteger.valueOf(j2));
}
return listProduct(arrayList).shiftLeft(numberOfTrailingZeros);
}
static BigInteger listProduct(List<BigInteger> list) {
return listProduct(list, 0, list.size());
}
static BigInteger listProduct(List<BigInteger> list, int i, int i2) {
int i3 = i2 - i;
if (i3 == 0) {
return BigInteger.ONE;
}
if (i3 == 1) {
return list.get(i);
}
if (i3 == 2) {
return list.get(i).multiply(list.get(i + 1));
}
if (i3 == 3) {
return list.get(i).multiply(list.get(i + 1)).multiply(list.get(i + 2));
}
int i4 = (i2 + i) >>> 1;
return listProduct(list, i, i4).multiply(listProduct(list, i4, i2));
}
public static BigInteger binomial(int i, int i2) {
MathPreconditions.checkNonNegative("n", i);
MathPreconditions.checkNonNegative("k", i2);
int i3 = 1;
Preconditions.checkArgument(i2 <= i, "k (%s) > n (%s)", i2, i);
if (i2 > (i >> 1)) {
i2 = i - i2;
}
if (i2 < LongMath.biggestBinomials.length && i <= LongMath.biggestBinomials[i2]) {
return BigInteger.valueOf(LongMath.binomial(i, i2));
}
BigInteger bigInteger = BigInteger.ONE;
long j = (long) i;
long j2 = 1;
int log2 = LongMath.log2(j, RoundingMode.CEILING);
while (true) {
int i4 = log2;
while (i3 < i2) {
int i5 = i - i3;
i3++;
i4 += log2;
if (i4 >= 63) {
bigInteger = bigInteger.multiply(BigInteger.valueOf(j)).divide(BigInteger.valueOf(j2));
j = (long) i5;
j2 = (long) i3;
} else {
j *= (long) i5;
j2 *= (long) i3;
}
}
return bigInteger.multiply(BigInteger.valueOf(j)).divide(BigInteger.valueOf(j2));
}
}
static boolean fitsInLong(BigInteger bigInteger) {
return bigInteger.bitLength() <= 63;
}
private BigIntegerMath() {
}
}
Download file