package defpackage;

import ar.tvplayer.core.domain.ˑᵱ;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Set;

/* renamed from: ˌᵽᵚ, reason: contains not printable characters */
/* loaded from: classes3.dex */
public abstract class AbstractC1658 extends AbstractC0220 {
    /* renamed from: ˀᵗᵝᵭ, reason: contains not printable characters */
    public static void m4716(int i, int i2, int i3, int[] iArr, int[] iArr2) {
        System.arraycopy(iArr, i2, iArr2, i, i3 - i2);
    }

    /* renamed from: ˀᵗᵩ, reason: contains not printable characters */
    public static List m4717(Object[] objArr) {
        int length = objArr.length;
        return length != 0 ? length != 1 ? Arrays.asList(Arrays.copyOf(objArr, objArr.length)) : Collections.singletonList(objArr[0]) : C3035.f11677;
    }

    /* renamed from: ˁˑᵰ, reason: contains not printable characters */
    public static Byte m4718(int i, byte[] bArr) {
        if (i < 0 || i >= bArr.length) {
            return null;
        }
        return Byte.valueOf(bArr[i]);
    }

    /* renamed from: ˆᵼᵷˊ, reason: contains not printable characters */
    public static Set m4719(Object[] objArr) {
        int length = objArr.length;
        if (length == 0) {
            return C2388.f9327;
        }
        if (length == 1) {
            return Collections.singleton(objArr[0]);
        }
        LinkedHashSet linkedHashSet = new LinkedHashSet(AbstractC4546.m9659(objArr.length));
        for (Object obj : objArr) {
            linkedHashSet.add(obj);
        }
        return linkedHashSet;
    }

    /* renamed from: ˊᵸˊ, reason: contains not printable characters */
    public static void m4720(byte[] bArr) {
        if (bArr.length > 1) {
            Arrays.sort(bArr);
        }
    }

    /* renamed from: ˎˑː, reason: contains not printable characters */
    public static void m4721(int i, int i2, byte[] bArr, byte[] bArr2) {
        System.arraycopy(bArr, i, bArr2, 0, i2 - i);
    }

    /* renamed from: ˑᵝﹳᵜ, reason: contains not printable characters */
    public static void m4722(byte[] bArr) {
        int length = (bArr.length / 2) - 1;
        if (length < 0) {
            return;
        }
        int length2 = bArr.length - 1;
        if (length < 0) {
            return;
        }
        int i = 0;
        while (true) {
            byte b = bArr[i];
            bArr[i] = bArr[length2];
            bArr[length2] = b;
            length2--;
            if (i == length) {
                return;
            } else {
                i++;
            }
        }
    }

    /* renamed from: ˑᵥˁ, reason: contains not printable characters */
    public static void m4723(int i, int i2, int i3, Object[] objArr, Object[] objArr2) {
        if ((i3 & 4) != 0) {
            i = 0;
        }
        if ((i3 & 8) != 0) {
            i2 = objArr.length;
        }
        System.arraycopy(objArr, i, objArr2, 0, i2 - i);
    }

    /* renamed from: ᐧﾞ, reason: contains not printable characters */
    public static ArrayList m4724(Object[] objArr) {
        ArrayList arrayList = new ArrayList();
        for (Object obj : objArr) {
            if (obj != null) {
                arrayList.add(obj);
            }
        }
        return arrayList;
    }

    /* renamed from: ᵙᵢᵨᵳ, reason: contains not printable characters */
    public static int m4725(Object[] objArr, Object obj) {
        int i = 0;
        if (obj == null) {
            int length = objArr.length;
            while (i < length) {
                if (objArr[i] == null) {
                    return i;
                }
                i++;
            }
            return -1;
        }
        int length2 = objArr.length;
        while (i < length2) {
            if (obj.equals(objArr[i])) {
                return i;
            }
            i++;
        }
        return -1;
    }

    /* renamed from: ᵡˎ, reason: contains not printable characters */
    public static void m4726(int i, int i2, int i3, Object[] objArr, Object[] objArr2) {
        System.arraycopy(objArr, i2, objArr2, i, i3 - i2);
    }

    /* renamed from: ᵡᵘˎʽ, reason: contains not printable characters */
    public static String m4727(byte[] bArr, String str, ˑᵱ r8, int i) {
        String str2 = (i & 2) != 0 ? "" : "[";
        String str3 = (i & 4) == 0 ? "]" : "";
        if ((i & 32) != 0) {
            r8 = null;
        }
        StringBuilder sb = new StringBuilder();
        sb.append((CharSequence) str2);
        int i2 = 0;
        for (byte b : bArr) {
            i2++;
            if (i2 > 1) {
                sb.append((CharSequence) str);
            }
            if (r8 != null) {
                sb.append((CharSequence) r8.ᵴᵳ(Byte.valueOf(b)));
            } else {
                sb.append((CharSequence) String.valueOf((int) b));
            }
        }
        sb.append((CharSequence) str3);
        return sb.toString();
    }

    /* renamed from: ᵡⁱᵥ, reason: contains not printable characters */
    public static boolean m4728(Object[] objArr, Object[] objArr2) {
        if (objArr == objArr2) {
            return true;
        }
        if (objArr.length == objArr2.length) {
            int length = objArr.length;
            for (int i = 0; i < length; i++) {
                Object obj = objArr[i];
                Object obj2 = objArr2[i];
                if (obj != obj2) {
                    if (obj != null && obj2 != null) {
                        if ((obj instanceof Object[]) && (obj2 instanceof Object[])) {
                            if (!m4728((Object[]) obj, (Object[]) obj2)) {
                            }
                        } else if ((obj instanceof byte[]) && (obj2 instanceof byte[])) {
                            if (!Arrays.equals((byte[]) obj, (byte[]) obj2)) {
                            }
                        } else if ((obj instanceof short[]) && (obj2 instanceof short[])) {
                            if (!Arrays.equals((short[]) obj, (short[]) obj2)) {
                            }
                        } else if ((obj instanceof int[]) && (obj2 instanceof int[])) {
                            if (!Arrays.equals((int[]) obj, (int[]) obj2)) {
                            }
                        } else if ((obj instanceof long[]) && (obj2 instanceof long[])) {
                            if (!Arrays.equals((long[]) obj, (long[]) obj2)) {
                            }
                        } else if ((obj instanceof float[]) && (obj2 instanceof float[])) {
                            if (!Arrays.equals((float[]) obj, (float[]) obj2)) {
                            }
                        } else if ((obj instanceof double[]) && (obj2 instanceof double[])) {
                            if (!Arrays.equals((double[]) obj, (double[]) obj2)) {
                            }
                        } else if ((obj instanceof char[]) && (obj2 instanceof char[])) {
                            if (!Arrays.equals((char[]) obj, (char[]) obj2)) {
                            }
                        } else if ((obj instanceof boolean[]) && (obj2 instanceof boolean[])) {
                            if (!Arrays.equals((boolean[]) obj, (boolean[]) obj2)) {
                            }
                        } else if ((obj instanceof AbstractC1944) && (obj2 instanceof AbstractC1944)) {
                            if (!Arrays.equals((byte[]) null, (byte[]) null)) {
                            }
                        } else if ((obj instanceof AbstractC3087) && (obj2 instanceof AbstractC3087)) {
                            if (!Arrays.equals((short[]) null, (short[]) null)) {
                            }
                        } else if ((obj instanceof AbstractC4323) && (obj2 instanceof AbstractC4323)) {
                            if (!Arrays.equals((int[]) null, (int[]) null)) {
                            }
                        } else if ((obj instanceof AbstractC1007) && (obj2 instanceof AbstractC1007)) {
                            if (!Arrays.equals((long[]) null, (long[]) null)) {
                            }
                        } else if (!obj.equals(obj2)) {
                        }
                    }
                }
            }
            return true;
        }
        return false;
    }

    /* renamed from: ᵤᵙᵷ, reason: contains not printable characters */
    public static boolean m4729(Object[] objArr, Object obj) {
        return m4725(objArr, obj) >= 0;
    }

    /* renamed from: ᵧـˌᵎ, reason: contains not printable characters */
    public static void m4730(long[] jArr) {
        Arrays.fill(jArr, 0, jArr.length, -9187201950435737472L);
    }

    /* renamed from: ᵮᵠـˌ, reason: contains not printable characters */
    public static byte[] m4731(byte[] bArr, int i, int i2) {
        AbstractC0220.m1498(i2, bArr.length);
        return Arrays.copyOfRange(bArr, i, i2);
    }

    /* renamed from: ᵶʔᵢˊ, reason: contains not printable characters */
    public static Object m4732(Object[] objArr) {
        if (objArr.length != 0) {
            return objArr[0];
        }
        throw new NoSuchElementException("Array is empty.");
    }

    /* renamed from: ᵺʙ, reason: contains not printable characters */
    public static void m4733(Object[] objArr, C0434 c0434) {
        Arrays.fill(objArr, 0, objArr.length, c0434);
    }

    /* renamed from: ᵾᵬ, reason: contains not printable characters */
    public static boolean m4734(int[] iArr, int i) {
        int length = iArr.length;
        int i2 = 0;
        while (true) {
            if (i2 >= length) {
                i2 = -1;
                break;
            }
            if (i == iArr[i2]) {
                break;
            }
            i2++;
        }
        return i2 >= 0;
    }

    /* renamed from: ﾞⁱ, reason: contains not printable characters */
    public static Object m4735(int i, Object[] objArr) {
        if (i < 0 || i >= objArr.length) {
            return null;
        }
        return objArr[i];
    }
}