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;

/* renamed from: ᵚᵩʛʩ, reason: contains not printable characters */
/* loaded from: classes.dex */
public abstract class AbstractC2692 extends AbstractC3821 implements List, RandomAccess, j$.util.List {

    /* renamed from: ᵢˇᵭ, reason: contains not printable characters */
    public static final C4421 f10429 = new C4421(C4471.f16684, 0);

    /* renamed from: ˌᵜᵹᵩ, reason: contains not printable characters */
    public static AbstractC2692 m6693(Iterable iterable) {
        if (iterable instanceof Collection) {
            return m6700((Collection) iterable);
        }
        Iterator it = iterable.iterator();
        if (!it.hasNext()) {
            return C4471.f16684;
        }
        Object next = it.next();
        if (!it.hasNext()) {
            return m6702(next);
        }
        C4704 c4704 = new C4704(4);
        c4704.m3197(next);
        while (it.hasNext()) {
            c4704.m3197(it.next());
        }
        return c4704.m9892();
    }

    /* renamed from: ˑᵱ, reason: contains not printable characters */
    public static C4471 m6694(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 m6695(length, objArr2);
    }

    /* renamed from: ᵝᵵᵺ, reason: contains not printable characters */
    public static C4471 m6695(int i, Object[] objArr) {
        return i == 0 ? C4471.f16684 : new C4471(i, objArr);
    }

    /* renamed from: ᵡʠ, reason: contains not printable characters */
    public static C4471 m6696(Long l, Long l2, Long l3, Long l4, Long l5) {
        Object[] objArr = {l, l2, l3, l4, l5};
        ᵕˏᵛ.ᵻᵢﹳᵰ(5, objArr);
        return m6695(5, objArr);
    }

    /* renamed from: ᵢˇᵭ, reason: contains not printable characters */
    public static C4471 m6697(Comparator comparator, List list) {
        comparator.getClass();
        if (!AbstractC3915.m8586(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 m6695(array.length, array);
    }

    /* renamed from: ᵨᵳʝ, reason: contains not printable characters */
    public static C4471 m6698(Object obj, Object obj2) {
        Object[] objArr = {obj, obj2};
        ᵕˏᵛ.ᵻᵢﹳᵰ(2, objArr);
        return m6695(2, objArr);
    }

    /* renamed from: ᵪʩ, reason: contains not printable characters */
    public static C4471 m6699(Object[] objArr) {
        if (objArr.length == 0) {
            return C4471.f16684;
        }
        Object[] objArr2 = (Object[]) objArr.clone();
        ᵕˏᵛ.ᵻᵢﹳᵰ(objArr2.length, objArr2);
        return m6695(objArr2.length, objArr2);
    }

    /* renamed from: ᵯٴᵦ, reason: contains not printable characters */
    public static AbstractC2692 m6700(Collection collection) {
        if (!(collection instanceof AbstractC3821)) {
            Object[] array = collection.toArray();
            ᵕˏᵛ.ᵻᵢﹳᵰ(array.length, array);
            return m6695(array.length, array);
        }
        AbstractC2692 abstractC2692Mo4464 = ((AbstractC3821) collection).mo4464();
        if (!abstractC2692Mo4464.mo4897()) {
            return abstractC2692Mo4464;
        }
        Object[] array2 = abstractC2692Mo4464.toArray(AbstractC3821.f14216);
        return m6695(array2.length, array2);
    }

    /* renamed from: ᵶᵷᵕ, reason: contains not printable characters */
    public static C4704 m6701() {
        return new C4704(4);
    }

    /* renamed from: ᵸʓᵠ, reason: contains not printable characters */
    public static C4471 m6702(Object obj) {
        Object[] objArr = {obj};
        ᵕˏᵛ.ᵻᵢﹳᵰ(1, objArr);
        return m6695(1, objArr);
    }

    /* renamed from: ᵸˑ, reason: contains not printable characters */
    public static C4704 m6703(int i) {
        ˏᵭᵔᵬ.ᵻᵢﹳᵰ(i, "expectedSize");
        return new C4704(i);
    }

    @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.AbstractC3821, java.util.AbstractCollection, java.util.Collection
    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.AbstractC3821, 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.AbstractC3821
    /* renamed from: ˏᵙ */
    public int mo4462(int i, Object[] objArr) {
        int size = size();
        for (int i2 = 0; i2 < size; i2++) {
            objArr[i + i2] = get(i2);
        }
        return i + size;
    }

    /* renamed from: ᵧᵾˀˈ */
    public AbstractC2692 mo4898() {
        return size() <= 1 ? this : new C1714(this);
    }

    @Override // java.util.List
    /* renamed from: ᵳٴᵶ, reason: contains not printable characters and merged with bridge method [inline-methods] */
    public final C4421 listIterator(int i) {
        ᵛᵾˏ.ˑᵱ(i, size());
        return isEmpty() ? f10429 : new C4421(this, i);
    }

    @Override // defpackage.AbstractC3821
    /* renamed from: ᵴᵳ */
    public final AbstractC2692 mo4464() {
        return this;
    }

    @Override // defpackage.AbstractC3821
    /* renamed from: ᵹᵝᵶ */
    public final AbstractC5447 iterator() {
        return listIterator(0);
    }

    @Override // java.util.List
    /* renamed from: ᵿʗᵝʽ, reason: merged with bridge method [inline-methods] */
    public AbstractC2692 subList(int i, int i2) {
        ᵛᵾˏ.ᵧᵾˀˈ(i, i2, size());
        int i3 = i2 - i;
        return i3 == size() ? this : i3 == 0 ? C4471.f16684 : new C2199(this, i, i3);
    }
}