package com.google.common.primitives;

import com.google.common.base.Preconditions;
import java.math.BigInteger;

/* loaded from: classes.dex */
public final class UnsignedLongs {
    private static final long[] a = new long[37];
    private static final int[] b = new int[37];
    private static final int[] c = new int[37];

    static {
        BigInteger bigInteger = new BigInteger("10000000000000000", 16);
        for (int i = 2; i <= 36; i++) {
            long j = i;
            a[i] = b(-1L, j);
            b[i] = (int) c(-1L, j);
            c[i] = bigInteger.toString(i).length() - 1;
        }
    }

    public static int a(long j, long j2) {
        return Longs.a(a(j), a(j2));
    }

    private static long a(long j) {
        return j ^ Long.MIN_VALUE;
    }

    public static long b(long j, long j2) {
        if (j2 < 0) {
            return a(j, j2) < 0 ? 0L : 1L;
        }
        if (j >= 0) {
            return j / j2;
        }
        long j3 = ((j >>> 1) / j2) << 1;
        return j3 + (a(j - (j3 * j2), j2) < 0 ? 0 : 1);
    }

    public static long c(long j, long j2) {
        if (j2 < 0) {
            return a(j, j2) < 0 ? j : j - j2;
        }
        if (j >= 0) {
            return j % j2;
        }
        long j3 = j - ((((j >>> 1) / j2) << 1) * j2);
        if (a(j3, j2) < 0) {
            j2 = 0;
        }
        return j3 - j2;
    }

    public static long a(String str, int i) {
        Preconditions.a(str);
        if (str.length() == 0) {
            throw new NumberFormatException("empty string");
        }
        if (i < 2 || i > 36) {
            throw new NumberFormatException("illegal radix: " + i);
        }
        int i2 = c[i] - 1;
        long j = 0;
        for (int i3 = 0; i3 < str.length(); i3++) {
            int digit = Character.digit(str.charAt(i3), i);
            if (digit == -1) {
                throw new NumberFormatException(str);
            }
            if (i3 > i2 && a(j, digit, i)) {
                throw new NumberFormatException("Too large for unsigned long: " + str);
            }
            j = (j * i) + digit;
        }
        return j;
    }

    public static String b(long j) {
        return a(j, 10);
    }

    private static boolean a(long j, int i, int i2) {
        if (j < 0) {
            return true;
        }
        long[] jArr = a;
        if (j < jArr[i2]) {
            return false;
        }
        return j > jArr[i2] || i > b[i2];
    }

    public static String a(long j, int i) {
        long b2;
        Preconditions.a(i >= 2 && i <= 36, "radix (%s) must be between Character.MIN_RADIX and Character.MAX_RADIX", i);
        if (j == 0) {
            return "0";
        }
        if (j > 0) {
            return Long.toString(j, i);
        }
        char[] cArr = new char[64];
        int length = cArr.length;
        int i2 = i - 1;
        if ((i & i2) == 0) {
            int numberOfTrailingZeros = Integer.numberOfTrailingZeros(i);
            do {
                length--;
                cArr[length] = Character.forDigit(((int) j) & i2, i);
                j >>>= numberOfTrailingZeros;
            } while (j != 0);
        } else {
            if ((i & 1) == 0) {
                b2 = (j >>> 1) / (i >>> 1);
            } else {
                b2 = b(j, i);
            }
            long j2 = i;
            length--;
            cArr[length] = Character.forDigit((int) (j - (b2 * j2)), i);
            while (b2 > 0) {
                length--;
                cArr[length] = Character.forDigit((int) (b2 % j2), i);
                b2 /= j2;
            }
        }
        return new String(cArr, length, cArr.length - length);
    }
}