package defpackage;

import java.nio.ByteOrder;
import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.util.Comparator;
import java.util.Objects;
import sun.misc.Unsafe;

/* JADX INFO: loaded from: classes2.dex */
@dz3
@gi2
@sw4
public final class j8a {

    @tma
    public static class a {
        public static final Comparator a;

        /* JADX WARN: Failed to restore enum class, 'enum' modifier and super class removed */
        /* JADX WARN: Unknown enum class pattern. Please report as an issue! */
        /* JADX INFO: renamed from: j8a$a$a, reason: collision with other inner class name */
        public static final class EnumC0149a implements Comparator<byte[]> {
            public static final EnumC0149a a;
            public static final /* synthetic */ EnumC0149a[] b;

            static {
                EnumC0149a enumC0149a = new EnumC0149a("INSTANCE", 0);
                a = enumC0149a;
                b = new EnumC0149a[]{enumC0149a};
            }

            public static EnumC0149a valueOf(String str) {
                return (EnumC0149a) Enum.valueOf(EnumC0149a.class, str);
            }

            public static EnumC0149a[] values() {
                return (EnumC0149a[]) b.clone();
            }

            @Override // java.util.Comparator
            public final int compare(byte[] bArr, byte[] bArr2) {
                byte[] bArr3 = bArr;
                byte[] bArr4 = bArr2;
                int iMin = Math.min(bArr3.length, bArr4.length);
                for (int i = 0; i < iMin; i++) {
                    int i2 = (bArr3[i] & 255) - (bArr4[i] & 255);
                    if (i2 != 0) {
                        return i2;
                    }
                }
                return bArr3.length - bArr4.length;
            }

            @Override // java.lang.Enum
            public final String toString() {
                return "UnsignedBytes.lexicographicalComparator() (pure Java version)";
            }
        }

        /* JADX WARN: Failed to restore enum class, 'enum' modifier and super class removed */
        /* JADX WARN: Unknown enum class pattern. Please report as an issue! */
        @tma
        public static final class b implements Comparator<byte[]> {
            public static final Unsafe b;
            public static final int c;

            /* JADX INFO: Fake field, exist only in values array */
            b EF5;
            public static final /* synthetic */ b[] d = {new b("INSTANCE", 0)};
            public static final boolean a = ByteOrder.nativeOrder().equals(ByteOrder.BIG_ENDIAN);

            static {
                Unsafe unsafeB = b();
                b = unsafeB;
                int iArrayBaseOffset = unsafeB.arrayBaseOffset(byte[].class);
                c = iArrayBaseOffset;
                if (!"64".equals(System.getProperty("sun.arch.data.model")) || iArrayBaseOffset % 8 != 0 || unsafeB.arrayIndexScale(byte[].class) != 1) {
                    throw new Error();
                }
            }

            public static int a(byte[] bArr, byte[] bArr2) {
                int iMin = Math.min(bArr.length, bArr2.length);
                int i = iMin & (-8);
                int i2 = 0;
                while (i2 < i) {
                    Unsafe unsafe = b;
                    long j = ((long) c) + ((long) i2);
                    long j2 = unsafe.getLong(bArr, j);
                    long j3 = unsafe.getLong(bArr2, j);
                    if (j2 != j3) {
                        if (a) {
                            return Long.compareUnsigned(j2, j3);
                        }
                        int iNumberOfTrailingZeros = Long.numberOfTrailingZeros(j2 ^ j3) & (-8);
                        return ((int) ((j2 >>> iNumberOfTrailingZeros) & 255)) - ((int) ((j3 >>> iNumberOfTrailingZeros) & 255));
                    }
                    i2 += 8;
                }
                while (i2 < iMin) {
                    int i3 = (bArr[i2] & 255) - (bArr2[i2] & 255);
                    if (i3 != 0) {
                        return i3;
                    }
                    i2++;
                }
                return bArr.length - bArr2.length;
            }

            public static Unsafe b() {
                try {
                    try {
                        return Unsafe.getUnsafe();
                    } catch (PrivilegedActionException e) {
                        throw new RuntimeException("Could not initialize intrinsics", e.getCause());
                    }
                } catch (SecurityException unused) {
                    return (Unsafe) AccessController.doPrivileged(new k8a());
                }
            }

            public static b valueOf(String str) {
                return (b) Enum.valueOf(b.class, str);
            }

            public static b[] values() {
                return (b[]) d.clone();
            }

            @Override // java.util.Comparator
            public final /* bridge */ /* synthetic */ int compare(byte[] bArr, byte[] bArr2) {
                return a(bArr, bArr2);
            }

            @Override // java.lang.Enum
            public final String toString() {
                return "UnsignedBytes.lexicographicalComparator() (sun.misc.Unsafe version)";
            }
        }

        static {
            Comparator comparator;
            try {
                Object[] enumConstants = Class.forName(a.class.getName().concat("$UnsafeComparator")).getEnumConstants();
                Objects.requireNonNull(enumConstants);
                comparator = (Comparator) enumConstants[0];
            } catch (Throwable unused) {
                comparator = EnumC0149a.a;
            }
            a = comparator;
        }
    }

    public static byte a(long j) {
        if7.d("out of range: %s", (j >> 8) == 0, j);
        return (byte) j;
    }
}