package defpackage;

import j$.util.List;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.RandomAccess;
import java.util.function.UnaryOperator;

/* JADX INFO: renamed from: ᵲˑ, reason: contains not printable characters */
/* JADX INFO: loaded from: classes.dex */
public abstract class AbstractC4509 extends AbstractC5055 implements List, RandomAccess, j$.util.List {

    /* JADX INFO: renamed from: ᵜᵪʾ, reason: contains not printable characters */
    public static final C2822 f17159 = new C2822(C2598.f10048, 0);

    /* JADX INFO: renamed from: ˉᵲ, reason: contains not printable characters */
    public static C2598 m9553(Object obj) {
        Object[] objArr = {obj};
        ᵗʓ.ᵷᵺʾᵖ(1, objArr);
        return m9563(1, objArr);
    }

    /* JADX INFO: renamed from: ˊᵙᵾᵲ, reason: contains not printable characters */
    public static C2598 m9554(Long l, Long l2, Long l3, Long l4, Long l5) {
        Object[] objArr = {l, l2, l3, l4, l5};
        ᵗʓ.ᵷᵺʾᵖ(5, objArr);
        return m9563(5, objArr);
    }

    /* JADX INFO: renamed from: ˊᵨᵧ, reason: contains not printable characters */
    public static C2598 m9555(String str, String str2, String str3, String str4, String str5, String str6, String str7, String str8, String str9, String str10, String str11, String str12, Object... objArr) {
        ᵻᵪ.ᵻʽᵯ("the total number of elements must fit in an int", objArr.length <= 2147483635);
        int length = objArr.length + 12;
        Object[] objArr2 = new Object[length];
        objArr2[0] = str;
        objArr2[1] = str2;
        objArr2[2] = str3;
        objArr2[3] = str4;
        objArr2[4] = str5;
        objArr2[5] = str6;
        objArr2[6] = str7;
        objArr2[7] = str8;
        objArr2[8] = str9;
        objArr2[9] = str10;
        objArr2[10] = str11;
        objArr2[11] = str12;
        System.arraycopy(objArr, 0, objArr2, 12, objArr.length);
        ᵗʓ.ᵷᵺʾᵖ(length, objArr2);
        return m9563(length, objArr2);
    }

    /* JADX INFO: renamed from: ˋˈ, reason: contains not printable characters */
    public static C2598 m9556(Object[] objArr) {
        if (objArr.length == 0) {
            return C2598.f10048;
        }
        Object[] objArr2 = (Object[]) objArr.clone();
        ᵗʓ.ᵷᵺʾᵖ(objArr2.length, objArr2);
        return m9563(objArr2.length, objArr2);
    }

    /* JADX INFO: renamed from: ˏːˆ, reason: contains not printable characters */
    public static C2598 m9557(Object obj, Object obj2) {
        Object[] objArr = {obj, obj2};
        ᵗʓ.ᵷᵺʾᵖ(2, objArr);
        return m9563(2, objArr);
    }

    /* JADX INFO: renamed from: ᵜᵪʾ, reason: contains not printable characters */
    public static C2598 m9558(Comparator comparator, List list) {
        comparator.getClass();
        if (!AbstractC0793.m2860(list)) {
            Iterator it = list.iterator();
            ArrayList arrayList = new ArrayList();
            it.getClass();
            while (it.hasNext()) {
                arrayList.add(it.next());
            }
            list = arrayList;
        }
        Object[] array = list.toArray();
        ᵗʓ.ᵷᵺʾᵖ(array.length, array);
        Arrays.sort(array, comparator);
        return m9563(array.length, array);
    }

    /* JADX INFO: renamed from: ᵝᵶ, reason: contains not printable characters */
    public static AbstractC4509 m9559(Collection collection) {
        if (!(collection instanceof AbstractC5055)) {
            Object[] array = collection.toArray();
            ᵗʓ.ᵷᵺʾᵖ(array.length, array);
            return m9563(array.length, array);
        }
        AbstractC4509 abstractC4509Mo1394 = ((AbstractC5055) collection).mo1394();
        if (!abstractC4509Mo1394.mo1397()) {
            return abstractC4509Mo1394;
        }
        Object[] array2 = abstractC4509Mo1394.toArray(AbstractC5055.f19103);
        return m9563(array2.length, array2);
    }

    /* JADX INFO: renamed from: ᵮᵣᵗˈ, reason: contains not printable characters */
    public static AbstractC4509 m9560(Iterable iterable) {
        if (iterable instanceof Collection) {
            return m9559((Collection) iterable);
        }
        Iterator it = iterable.iterator();
        if (!it.hasNext()) {
            return C2598.f10048;
        }
        Object next = it.next();
        if (!it.hasNext()) {
            return m9553(next);
        }
        C3975 c3975 = new C3975(4);
        c3975.m7406(next);
        while (it.hasNext()) {
            c3975.m7406(it.next());
        }
        return c3975.m8718();
    }

    /* JADX INFO: renamed from: ᵱᵽʡᵚ, reason: contains not printable characters */
    public static C3975 m9561() {
        return new C3975(4);
    }

    /* JADX INFO: renamed from: ᵶᵥᵝ, reason: contains not printable characters */
    public static C3975 m9562(int i) {
        ˑᵕʾ.ːˏᵟᵯ(i, "expectedSize");
        return new C3975(i);
    }

    /* JADX INFO: renamed from: ᵻʽᵯ, reason: contains not printable characters */
    public static C2598 m9563(int i, Object[] objArr) {
        return i == 0 ? C2598.f10048 : new C2598(i, objArr);
    }

    @Override // java.util.List
    public final void add(int i, Object obj) {
        throw new UnsupportedOperationException();
    }

    @Override // java.util.List
    public final boolean addAll(int i, Collection collection) {
        throw new UnsupportedOperationException();
    }

    @Override // defpackage.AbstractC5055, java.util.AbstractCollection, java.util.Collection, java.util.Set
    public boolean contains(Object obj) {
        return indexOf(obj) >= 0;
    }

    @Override // java.util.Collection, java.util.List
    public final boolean equals(Object obj) {
        if (obj != this) {
            if (obj instanceof List) {
                List list = (List) obj;
                int size = size();
                if (size == list.size()) {
                    if (!(list instanceof RandomAccess)) {
                        Iterator it = iterator();
                        Iterator it2 = list.iterator();
                        while (it.hasNext()) {
                            if (it2.hasNext() && ᵥˇᵛˎ.ˏːˆ(it.next(), it2.next())) {
                            }
                        }
                        return !it2.hasNext();
                    }
                    for (int i = 0; i < size; i++) {
                        if (ᵥˇᵛˎ.ˏːˆ(get(i), list.get(i))) {
                        }
                    }
                }
            }
            return false;
        }
        return true;
    }

    @Override // java.util.Collection, java.util.List
    public final int hashCode() {
        int size = size();
        int i = 1;
        for (int i2 = 0; i2 < size; i2++) {
            i = ~(~(get(i2).hashCode() + (i * 31)));
        }
        return i;
    }

    public int indexOf(Object obj) {
        if (obj == null) {
            return -1;
        }
        int size = size();
        for (int i = 0; i < size; i++) {
            if (obj.equals(get(i))) {
                return i;
            }
        }
        return -1;
    }

    @Override // defpackage.AbstractC5055, java.util.AbstractCollection, java.util.Collection, java.lang.Iterable, java.util.List
    public Iterator iterator() {
        return listIterator(0);
    }

    public int lastIndexOf(Object obj) {
        if (obj == null) {
            return -1;
        }
        for (int size = size() - 1; size >= 0; size--) {
            if (obj.equals(get(size))) {
                return size;
            }
        }
        return -1;
    }

    public ListIterator listIterator() {
        return listIterator(0);
    }

    @Override // java.util.List
    public final Object remove(int i) {
        throw new UnsupportedOperationException();
    }

    @Override // java.util.List, j$.util.List
    public /* synthetic */ void replaceAll(UnaryOperator unaryOperator) {
        List.CC.$default$replaceAll(this, unaryOperator);
    }

    @Override // java.util.List
    public final Object set(int i, Object obj) {
        throw new UnsupportedOperationException();
    }

    @Override // java.util.List, j$.util.List
    public /* synthetic */ void sort(Comparator comparator) {
        List.CC.$default$sort(this, comparator);
    }

    @Override // defpackage.AbstractC5055
    /* JADX INFO: renamed from: ʽˈˋ */
    public final AbstractC4509 mo1394() {
        return this;
    }

    @Override // defpackage.AbstractC5055
    /* JADX INFO: renamed from: ˊᵫᵗ */
    public final AbstractC0228 iterator() {
        return listIterator(0);
    }

    /* JADX INFO: renamed from: ˌᴵ */
    public AbstractC4509 mo6838() {
        return size() <= 1 ? this : new C2856(this);
    }

    @Override // defpackage.AbstractC5055
    /* JADX INFO: renamed from: ːˏᵟᵯ */
    public int mo1396(int i, Object[] objArr) {
        int size = size();
        for (int i2 = 0; i2 < size; i2++) {
            objArr[i + i2] = get(i2);
        }
        return i + size;
    }

    @Override // java.util.List
    /* JADX INFO: renamed from: ᵔᵖᵹᵫ, reason: merged with bridge method [inline-methods] */
    public AbstractC4509 subList(int i, int i2) {
        ᵻᵪ.ˏːˆ(i, i2, size());
        int i3 = i2 - i;
        return i3 == size() ? this : i3 == 0 ? C2598.f10048 : new C1951(this, i, i3);
    }

    @Override // java.util.List
    /* JADX INFO: renamed from: ᵪᵹᵥᵻ, reason: contains not printable characters and merged with bridge method [inline-methods] */
    public final C2822 listIterator(int i) {
        ᵻᵪ.ˉᵲ(i, size());
        return isEmpty() ? f17159 : new C2822(this, i);
    }
}