package x4;

import I2.C0317a;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Set;
import m3.AbstractC2478m;
import n2.AbstractC2612c;

/* JADX INFO: renamed from: x4.p, reason: case insensitive filesystem */
/* JADX INFO: loaded from: classes3.dex */
public abstract class AbstractC3250p extends AbstractC2478m {
    public static void A(long[] jArr, long[] destination, int i6, int i7, int i8) {
        kotlin.jvm.internal.o.h(jArr, "<this>");
        kotlin.jvm.internal.o.h(destination, "destination");
        System.arraycopy(jArr, i7, destination, i6, i8 - i7);
    }

    public static void B(Object[] objArr, int i6, Object[] destination, int i7, int i8) {
        kotlin.jvm.internal.o.h(objArr, "<this>");
        kotlin.jvm.internal.o.h(destination, "destination");
        System.arraycopy(objArr, i7, destination, i6, i8 - i7);
    }

    public static /* synthetic */ void C(int i6, int i7, int i8, int[] iArr, int[] iArr2) {
        if ((i8 & 2) != 0) {
            i6 = 0;
        }
        if ((i8 & 8) != 0) {
            i7 = iArr.length;
        }
        x(i6, 0, i7, iArr, iArr2);
    }

    public static /* synthetic */ void E(Object[] objArr, int i6, Object[] objArr2, int i7, int i8) {
        if ((i8 & 4) != 0) {
            i6 = 0;
        }
        if ((i8 & 8) != 0) {
            i7 = objArr.length;
        }
        B(objArr, 0, objArr2, i6, i7);
    }

    public static byte[] F(byte[] bArr, int i6, int i7) {
        kotlin.jvm.internal.o.h(bArr, "<this>");
        AbstractC2478m.e(i7, bArr.length);
        byte[] bArrCopyOfRange = Arrays.copyOfRange(bArr, i6, i7);
        kotlin.jvm.internal.o.g(bArrCopyOfRange, "copyOfRange(...)");
        return bArrCopyOfRange;
    }

    public static Object[] G(Object[] objArr, int i6, int i7) {
        kotlin.jvm.internal.o.h(objArr, "<this>");
        AbstractC2478m.e(i7, objArr.length);
        Object[] objArrCopyOfRange = Arrays.copyOfRange(objArr, i6, i7);
        kotlin.jvm.internal.o.g(objArrCopyOfRange, "copyOfRange(...)");
        return objArrCopyOfRange;
    }

    public static void H(Object[] objArr, C0317a c0317a, int i6, int i7) {
        kotlin.jvm.internal.o.h(objArr, "<this>");
        Arrays.fill(objArr, i6, i7, c0317a);
    }

    public static void I(long[] jArr, long j4) {
        int length = jArr.length;
        kotlin.jvm.internal.o.h(jArr, "<this>");
        Arrays.fill(jArr, 0, length, j4);
    }

    public static /* synthetic */ void J(Object[] objArr, C0317a c0317a) {
        H(objArr, c0317a, 0, objArr.length);
    }

    public static List K(Object[] objArr) {
        ArrayList arrayList = new ArrayList();
        for (Object obj : objArr) {
            if (obj != null) {
                arrayList.add(obj);
            }
        }
        return arrayList;
    }

    public static Float L(float[] fArr) {
        kotlin.jvm.internal.o.h(fArr, "<this>");
        if (fArr.length == 0) {
            return null;
        }
        return Float.valueOf(fArr[0]);
    }

    public static P4.g M(int[] iArr) {
        return new P4.g(0, iArr.length - 1, 1);
    }

    public static int N(long[] jArr) {
        kotlin.jvm.internal.o.h(jArr, "<this>");
        return jArr.length - 1;
    }

    public static Object O(int i6, Object[] objArr) {
        kotlin.jvm.internal.o.h(objArr, "<this>");
        if (i6 < 0 || i6 >= objArr.length) {
            return null;
        }
        return objArr[i6];
    }

    public static int P(Object[] objArr, Object obj) {
        kotlin.jvm.internal.o.h(objArr, "<this>");
        int i6 = 0;
        if (obj == null) {
            int length = objArr.length;
            while (i6 < length) {
                if (objArr[i6] == null) {
                    return i6;
                }
                i6++;
            }
            return -1;
        }
        int length2 = objArr.length;
        while (i6 < length2) {
            if (obj.equals(objArr[i6])) {
                return i6;
            }
            i6++;
        }
        return -1;
    }

    public static String Q(byte[] bArr, String str, J4.c cVar, int i6) {
        String str2 = (i6 & 2) != 0 ? "" : "[";
        String str3 = (i6 & 4) == 0 ? "]" : "";
        if ((i6 & 32) != 0) {
            cVar = null;
        }
        kotlin.jvm.internal.o.h(bArr, "<this>");
        StringBuilder sb = new StringBuilder();
        sb.append((CharSequence) str2);
        int i7 = 0;
        for (byte b5 : bArr) {
            i7++;
            if (i7 > 1) {
                sb.append((CharSequence) str);
            }
            if (cVar != null) {
                sb.append((CharSequence) cVar.invoke(Byte.valueOf(b5)));
            } else {
                sb.append((CharSequence) String.valueOf((int) b5));
            }
        }
        sb.append((CharSequence) str3);
        return sb.toString();
    }

    public static String R(Object[] objArr, String str, String str2, int i6) {
        String str3 = (i6 & 1) != 0 ? ", " : ",";
        kotlin.jvm.internal.o.h(objArr, "<this>");
        StringBuilder sb = new StringBuilder();
        sb.append((CharSequence) str);
        int i7 = 0;
        for (Object obj : objArr) {
            i7++;
            if (i7 > 1) {
                sb.append((CharSequence) str3);
            }
            e4.C.l(sb, obj, null);
        }
        sb.append((CharSequence) str2);
        return sb.toString();
    }

    public static Float S(float[] fArr) {
        kotlin.jvm.internal.o.h(fArr, "<this>");
        if (fArr.length == 0) {
            return null;
        }
        return Float.valueOf(fArr[fArr.length - 1]);
    }

    public static byte[] T(byte[] bArr, byte[] elements) {
        kotlin.jvm.internal.o.h(bArr, "<this>");
        kotlin.jvm.internal.o.h(elements, "elements");
        int length = bArr.length;
        int length2 = elements.length;
        byte[] bArrCopyOf = Arrays.copyOf(bArr, length + length2);
        System.arraycopy(elements, 0, bArrCopyOf, length, length2);
        kotlin.jvm.internal.o.e(bArrCopyOf);
        return bArrCopyOf;
    }

    public static char U(char[] cArr) {
        int length = cArr.length;
        if (length == 0) {
            throw new NoSuchElementException("Array is empty.");
        }
        if (length == 1) {
            return cArr[0];
        }
        throw new IllegalArgumentException("Array has more than one element.");
    }

    public static List V(Object[] objArr, P4.g indices) {
        kotlin.jvm.internal.o.h(objArr, "<this>");
        kotlin.jvm.internal.o.h(indices, "indices");
        if (indices.isEmpty()) {
            return y.f26065a;
        }
        return r(G(objArr, indices.f5676a, indices.f5677b + 1));
    }

    public static List W(long[] jArr) {
        kotlin.jvm.internal.o.h(jArr, "<this>");
        int length = jArr.length;
        if (length == 0) {
            return y.f26065a;
        }
        if (length == 1) {
            return AbstractC2612c.q(Long.valueOf(jArr[0]));
        }
        ArrayList arrayList = new ArrayList(jArr.length);
        for (long j4 : jArr) {
            arrayList.add(Long.valueOf(j4));
        }
        return arrayList;
    }

    public static List X(Object[] objArr) {
        kotlin.jvm.internal.o.h(objArr, "<this>");
        int length = objArr.length;
        return length != 0 ? length != 1 ? new ArrayList(new C3248n(objArr, false)) : AbstractC2612c.q(objArr[0]) : y.f26065a;
    }

    public static Set Y(Object[] objArr) {
        kotlin.jvm.internal.o.h(objArr, "<this>");
        int length = objArr.length;
        if (length == 0) {
            return C3224A.f26032a;
        }
        if (length == 1) {
            return m1.g.o(objArr[0]);
        }
        LinkedHashSet linkedHashSet = new LinkedHashSet(AbstractC3229F.u(objArr.length));
        for (Object obj : objArr) {
            linkedHashSet.add(obj);
        }
        return linkedHashSet;
    }

    public static List r(Object[] objArr) {
        kotlin.jvm.internal.o.h(objArr, "<this>");
        List listAsList = Arrays.asList(objArr);
        kotlin.jvm.internal.o.g(listAsList, "asList(...)");
        return listAsList;
    }

    public static R4.k s(Object[] objArr) {
        kotlin.jvm.internal.o.h(objArr, "<this>");
        return objArr.length == 0 ? R4.e.f6091a : new H4.f(objArr, 5);
    }

    public static boolean t(char[] cArr, char c6) {
        int length = cArr.length;
        int i6 = 0;
        while (true) {
            if (i6 >= length) {
                i6 = -1;
                break;
            }
            if (c6 == cArr[i6]) {
                break;
            }
            i6++;
        }
        return i6 >= 0;
    }

    public static boolean u(int[] iArr, int i6) {
        int length = iArr.length;
        int i7 = 0;
        while (true) {
            if (i7 >= length) {
                i7 = -1;
                break;
            }
            if (i6 == iArr[i7]) {
                break;
            }
            i7++;
        }
        return i7 >= 0;
    }

    public static boolean v(Object[] objArr, Object obj) {
        kotlin.jvm.internal.o.h(objArr, "<this>");
        return P(objArr, obj) >= 0;
    }

    public static boolean w(Object[] objArr, Object[] objArr2) {
        if (objArr == objArr2) {
            return true;
        }
        if (objArr == null || objArr2 == null || objArr.length != objArr2.length) {
            return false;
        }
        int length = objArr.length;
        for (int i6 = 0; i6 < length; i6++) {
            Object obj = objArr[i6];
            Object obj2 = objArr2[i6];
            if (obj != obj2) {
                if (obj == null || obj2 == null) {
                    return false;
                }
                if ((obj instanceof Object[]) && (obj2 instanceof Object[])) {
                    if (!w((Object[]) obj, (Object[]) obj2)) {
                        return false;
                    }
                } else if ((obj instanceof byte[]) && (obj2 instanceof byte[])) {
                    if (!Arrays.equals((byte[]) obj, (byte[]) obj2)) {
                        return false;
                    }
                } else if ((obj instanceof short[]) && (obj2 instanceof short[])) {
                    if (!Arrays.equals((short[]) obj, (short[]) obj2)) {
                        return false;
                    }
                } else if ((obj instanceof int[]) && (obj2 instanceof int[])) {
                    if (!Arrays.equals((int[]) obj, (int[]) obj2)) {
                        return false;
                    }
                } else if ((obj instanceof long[]) && (obj2 instanceof long[])) {
                    if (!Arrays.equals((long[]) obj, (long[]) obj2)) {
                        return false;
                    }
                } else if ((obj instanceof float[]) && (obj2 instanceof float[])) {
                    if (!Arrays.equals((float[]) obj, (float[]) obj2)) {
                        return false;
                    }
                } else if ((obj instanceof double[]) && (obj2 instanceof double[])) {
                    if (!Arrays.equals((double[]) obj, (double[]) obj2)) {
                        return false;
                    }
                } else if ((obj instanceof char[]) && (obj2 instanceof char[])) {
                    if (!Arrays.equals((char[]) obj, (char[]) obj2)) {
                        return false;
                    }
                } else if ((obj instanceof boolean[]) && (obj2 instanceof boolean[])) {
                    if (!Arrays.equals((boolean[]) obj, (boolean[]) obj2)) {
                        return false;
                    }
                } else if ((obj instanceof w4.s) && (obj2 instanceof w4.s)) {
                    w4.s sVar = (w4.s) obj2;
                    byte[] bArr = ((w4.s) obj).f25483a;
                    if (bArr == null) {
                        bArr = null;
                    }
                    byte[] bArr2 = sVar.f25483a;
                    if (!Arrays.equals(bArr, bArr2 != null ? bArr2 : null)) {
                        return false;
                    }
                } else if ((obj instanceof w4.z) && (obj2 instanceof w4.z)) {
                    w4.z zVar = (w4.z) obj2;
                    short[] sArr = ((w4.z) obj).f25490a;
                    if (sArr == null) {
                        sArr = null;
                    }
                    short[] sArr2 = zVar.f25490a;
                    if (!Arrays.equals(sArr, sArr2 != null ? sArr2 : null)) {
                        return false;
                    }
                } else if ((obj instanceof w4.u) && (obj2 instanceof w4.u)) {
                    w4.u uVar = (w4.u) obj2;
                    int[] iArr = ((w4.u) obj).f25485a;
                    if (iArr == null) {
                        iArr = null;
                    }
                    int[] iArr2 = uVar.f25485a;
                    if (!Arrays.equals(iArr, iArr2 != null ? iArr2 : null)) {
                        return false;
                    }
                } else if ((obj instanceof w4.w) && (obj2 instanceof w4.w)) {
                    w4.w wVar = (w4.w) obj2;
                    long[] jArr = ((w4.w) obj).f25487a;
                    if (jArr == null) {
                        jArr = null;
                    }
                    long[] jArr2 = wVar.f25487a;
                    if (!Arrays.equals(jArr, jArr2 != null ? jArr2 : null)) {
                        return false;
                    }
                } else if (!obj.equals(obj2)) {
                    return false;
                }
            }
        }
        return true;
    }

    public static void x(int i6, int i7, int i8, int[] iArr, int[] destination) {
        kotlin.jvm.internal.o.h(iArr, "<this>");
        kotlin.jvm.internal.o.h(destination, "destination");
        System.arraycopy(iArr, i7, destination, i6, i8 - i7);
    }

    public static void y(byte[] bArr, int i6, int i7, byte[] destination, int i8) {
        kotlin.jvm.internal.o.h(bArr, "<this>");
        kotlin.jvm.internal.o.h(destination, "destination");
        System.arraycopy(bArr, i7, destination, i6, i8 - i7);
    }

    public static void z(char[] cArr, char[] cArr2, int i6, int i7, int i8) {
        kotlin.jvm.internal.o.h(cArr, "<this>");
        System.arraycopy(cArr, i7, cArr2, i6, i8 - i7);
    }
}