package com.google.common.primitives;

import com.google.common.base.h;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

/* JADX INFO: loaded from: classes2.dex */
public abstract class a {
    public static List a(int... iArr) {
        return iArr.length == 0 ? Collections.emptyList() : new Ints$IntArrayAsList(0, iArr.length, iArr);
    }

    public static byte b(long j10) {
        h.c("out of range: %s", j10, (j10 >> 8) == 0);
        return (byte) j10;
    }

    public static int c(long j10) {
        int i10 = (int) j10;
        h.c("Out of range: %s", j10, ((long) i10) == j10);
        return i10;
    }

    public static long[] d(long[]... jArr) {
        long length = 0;
        for (long[] jArr2 : jArr) {
            length += (long) jArr2.length;
        }
        int i10 = (int) length;
        h.c("the total number of elements (%s) in the arrays must fit in an int", length, length == ((long) i10));
        long[] jArr3 = new long[i10];
        int length2 = 0;
        for (long[] jArr4 : jArr) {
            System.arraycopy(jArr4, 0, jArr3, length2, jArr4.length);
            length2 += jArr4.length;
        }
        return jArr3;
    }

    public static int e(byte b10, byte b11, byte b12, byte b13) {
        return (b10 << 24) | ((b11 & 255) << 16) | ((b12 & 255) << 8) | (b13 & 255);
    }

    public static int f(long j10) {
        return (int) (j10 ^ (j10 >>> 32));
    }

    public static int g(int[] iArr, int i10, int i11, int i12) {
        while (i11 < i12) {
            if (iArr[i11] == i10) {
                return i11;
            }
            i11++;
        }
        return -1;
    }

    public static int h(long j10) {
        if (j10 > 2147483647L) {
            return Integer.MAX_VALUE;
        }
        if (j10 < -2147483648L) {
            return Integer.MIN_VALUE;
        }
        return (int) j10;
    }

    public static int[] i(Collection collection) {
        if (collection instanceof Ints$IntArrayAsList) {
            Ints$IntArrayAsList ints$IntArrayAsList = (Ints$IntArrayAsList) collection;
            return Arrays.copyOfRange(ints$IntArrayAsList.array, ints$IntArrayAsList.start, ints$IntArrayAsList.end);
        }
        Object[] array = collection.toArray();
        int length = array.length;
        int[] iArr = new int[length];
        for (int i10 = 0; i10 < length; i10++) {
            Object obj = array[i10];
            obj.getClass();
            iArr[i10] = ((Number) obj).intValue();
        }
        return iArr;
    }

    /* JADX WARN: Removed duplicated region for block: B:4:0x000b  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public static Integer j(String str) {
        byte b10;
        Long lValueOf;
        byte b11;
        str.getClass();
        if (str.isEmpty()) {
            lValueOf = null;
        } else {
            int i10 = str.charAt(0) == '-' ? 1 : 0;
            if (i10 != str.length()) {
                int i11 = i10 + 1;
                char cCharAt = str.charAt(i10);
                if (cCharAt < 128) {
                    b10 = b.f23760a[cCharAt];
                } else {
                    byte[] bArr = b.f23760a;
                    b10 = -1;
                }
                if (b10 >= 0 && b10 < 10) {
                    long j10 = -b10;
                    long j11 = 10;
                    long j12 = Long.MIN_VALUE / j11;
                    while (true) {
                        if (i11 < str.length()) {
                            int i12 = i11 + 1;
                            char cCharAt2 = str.charAt(i11);
                            if (cCharAt2 < 128) {
                                b11 = b.f23760a[cCharAt2];
                            } else {
                                byte[] bArr2 = b.f23760a;
                                b11 = -1;
                            }
                            if (b11 < 0 || b11 >= 10 || j10 < j12) {
                                break;
                            }
                            long j13 = j10 * j11;
                            long j14 = b11;
                            if (j13 < j14 - Long.MIN_VALUE) {
                                break;
                            }
                            j10 = j13 - j14;
                            i11 = i12;
                        } else if (i10 != 0) {
                            lValueOf = Long.valueOf(j10);
                        } else {
                            if (j10 == Long.MIN_VALUE) {
                                break;
                            }
                            lValueOf = Long.valueOf(-j10);
                        }
                    }
                    lValueOf = null;
                }
            }
        }
        if (lValueOf == null || lValueOf.longValue() != lValueOf.intValue()) {
            return null;
        }
        return Integer.valueOf(lValueOf.intValue());
    }
}