package defpackage;

import java.util.AbstractCollection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.ListIterator;
import java.util.NoSuchElementException;
import java.util.RandomAccess;
import java.util.Set;

/* renamed from: ᵛᵵ, reason: contains not printable characters */
/* loaded from: classes3.dex */
public abstract class AbstractC2767 extends AbstractC4673 {
    /* renamed from: ʽᵢˊ, reason: contains not printable characters */
    public static ArrayList m6807(Collection collection, Object obj) {
        ArrayList arrayList = new ArrayList(collection.size() + 1);
        arrayList.addAll(collection);
        arrayList.add(obj);
        return arrayList;
    }

    /* renamed from: ʾˋˊᵽ, reason: contains not printable characters */
    public static void m6808(ArrayList arrayList) {
        if (arrayList.isEmpty()) {
            return;
        }
        arrayList.remove(AbstractC2240.m5908(arrayList));
    }

    /* renamed from: ʾᵻᵭٴ, reason: contains not printable characters */
    public static Object m6809(List list) {
        if (list.isEmpty()) {
            throw new NoSuchElementException("List is empty.");
        }
        return list.get(0);
    }

    /* renamed from: ʿᵘˆ, reason: contains not printable characters */
    public static void m6810(ArrayList arrayList, InterfaceC0362 interfaceC0362) {
        m6832(arrayList, interfaceC0362, true);
    }

    /* renamed from: ˀˁᵨ, reason: contains not printable characters */
    public static boolean m6811(Iterable iterable, Object obj) {
        int iIndexOf;
        if (iterable instanceof Collection) {
            return ((Collection) iterable).contains(obj);
        }
        if (!(iterable instanceof List)) {
            Iterator it = iterable.iterator();
            int i = 0;
            while (true) {
                if (!it.hasNext()) {
                    iIndexOf = -1;
                    break;
                }
                Object next = it.next();
                if (i < 0) {
                    AbstractC2240.m5909();
                    throw null;
                }
                if (ᵲᵝᵪ.ᵹᵝᵶ(obj, next)) {
                    iIndexOf = i;
                    break;
                }
                i++;
            }
        } else {
            iIndexOf = ((List) iterable).indexOf(obj);
        }
        return iIndexOf >= 0;
    }

    /* renamed from: ˆʕ, reason: contains not printable characters */
    public static Set m6812(Iterable iterable) {
        if (iterable instanceof Collection) {
            Collection collection = (Collection) iterable;
            int size = collection.size();
            if (size != 0) {
                if (size == 1) {
                    return Collections.singleton(iterable instanceof List ? ((List) iterable).get(0) : collection.iterator().next());
                }
                LinkedHashSet linkedHashSet = new LinkedHashSet(AbstractC4546.m9659(collection.size()));
                m6831(iterable, linkedHashSet);
                return linkedHashSet;
            }
        } else {
            LinkedHashSet linkedHashSet2 = new LinkedHashSet();
            m6831(iterable, linkedHashSet2);
            int size2 = linkedHashSet2.size();
            if (size2 != 0) {
                return size2 != 1 ? linkedHashSet2 : Collections.singleton(linkedHashSet2.iterator().next());
            }
        }
        return C2388.f9327;
    }

    /* renamed from: ˆᵴᵜˏ, reason: contains not printable characters */
    public static Object m6813(int i, List list) {
        if (i < 0 || i >= list.size()) {
            return null;
        }
        return list.get(i);
    }

    /* renamed from: ˉᵴﹶ, reason: contains not printable characters */
    public static HashSet m6814(ArrayList arrayList) {
        HashSet hashSet = new HashSet(AbstractC4546.m9659(AbstractC3869.m8517(arrayList, 12)));
        m6831(arrayList, hashSet);
        return hashSet;
    }

    /* renamed from: ˊʾˊ, reason: contains not printable characters */
    public static List m6815(List list) {
        int size = list.size() - 1;
        if (size <= 0) {
            return C3035.f11677;
        }
        if (size == 1) {
            return Collections.singletonList(m6828(list));
        }
        ArrayList arrayList = new ArrayList(size);
        if (list instanceof RandomAccess) {
            int size2 = list.size();
            for (int i = 1; i < size2; i++) {
                arrayList.add(list.get(i));
            }
        } else {
            ListIterator listIterator = list.listIterator(1);
            while (listIterator.hasNext()) {
                arrayList.add(listIterator.next());
            }
        }
        return arrayList;
    }

    /* renamed from: ˌᵹᵨˑ, reason: contains not printable characters */
    public static ArrayList m6816(Iterable iterable) {
        ArrayList arrayList = new ArrayList();
        for (Object obj : iterable) {
            if (obj != null) {
                arrayList.add(obj);
            }
        }
        return arrayList;
    }

    /* renamed from: ᵎʾ, reason: contains not printable characters */
    public static List m6817(Iterable iterable, Comparator comparator) {
        if (!(iterable instanceof Collection)) {
            List listM6829 = m6829(iterable);
            if (((ArrayList) listM6829).size() > 1) {
                Collections.sort(listM6829, comparator);
            }
            return listM6829;
        }
        Collection collection = (Collection) iterable;
        if (collection.size() <= 1) {
            return m6825(iterable);
        }
        Object[] array = collection.toArray(new Object[0]);
        if (array.length > 1) {
            Arrays.sort(array, comparator);
        }
        return Arrays.asList(array);
    }

    /* renamed from: ᵠᵪˀᵻ, reason: contains not printable characters */
    public static ArrayList m6818(List list, List list2) {
        ArrayList arrayList = new ArrayList(list2.size() + list.size());
        arrayList.addAll(list);
        arrayList.addAll(list2);
        return arrayList;
    }

    /* renamed from: ᵠᵿː, reason: contains not printable characters */
    public static Object m6819(Iterable iterable) {
        if (iterable instanceof List) {
            return m6809((List) iterable);
        }
        Iterator it = iterable.iterator();
        if (it.hasNext()) {
            return it.next();
        }
        throw new NoSuchElementException("Collection is empty.");
    }

    /* renamed from: ᵤᵼˑʠ, reason: contains not printable characters */
    public static Object m6821(List list) {
        if (list.isEmpty()) {
            return null;
        }
        return list.get(0);
    }

    /* renamed from: ᵥʩᵩˑ, reason: contains not printable characters */
    public static String m6822(Iterable iterable, String str, String str2, String str3, InterfaceC0362 interfaceC0362, int i) {
        if ((i & 1) != 0) {
            str = ", ";
        }
        String str4 = str;
        String str5 = (i & 2) != 0 ? "" : str2;
        String str6 = (i & 4) != 0 ? "" : str3;
        if ((i & 32) != 0) {
            interfaceC0362 = null;
        }
        StringBuilder sb = new StringBuilder();
        m6836(iterable, sb, str4, str5, str6, "...", interfaceC0362);
        return sb.toString();
    }

    /* renamed from: ᵦᵳˎ, reason: contains not printable characters */
    public static ArrayList m6823(List list) {
        return new ArrayList(list);
    }

    /* renamed from: ᵨٴ, reason: contains not printable characters */
    public static Object m6824(List list) {
        if (list.isEmpty()) {
            return null;
        }
        return list.get(list.size() - 1);
    }

    /* renamed from: ᵪᵛʿ, reason: contains not printable characters */
    public static List m6825(Iterable iterable) {
        if (!(iterable instanceof Collection)) {
            return AbstractC2240.m5914(m6829(iterable));
        }
        Collection collection = (Collection) iterable;
        int size = collection.size();
        if (size == 0) {
            return C3035.f11677;
        }
        if (size != 1) {
            return new ArrayList(collection);
        }
        return Collections.singletonList(iterable instanceof List ? ((List) iterable).get(0) : collection.iterator().next());
    }

    /* renamed from: ᵫᵮʾ, reason: contains not printable characters */
    public static void m6826(Iterable iterable, AbstractCollection abstractCollection) {
        if (iterable instanceof Collection) {
            abstractCollection.addAll((Collection) iterable);
            return;
        }
        Iterator it = iterable.iterator();
        while (it.hasNext()) {
            abstractCollection.add(it.next());
        }
    }

    /* renamed from: ᵰʖʢ, reason: contains not printable characters */
    public static Object m6827(List list) {
        if (list.isEmpty()) {
            throw new NoSuchElementException("List is empty.");
        }
        return list.remove(AbstractC2240.m5908(list));
    }

    /* renamed from: ᵲᵟ, reason: contains not printable characters */
    public static Object m6828(List list) {
        if (list.isEmpty()) {
            throw new NoSuchElementException("List is empty.");
        }
        return list.get(AbstractC2240.m5908(list));
    }

    /* renamed from: ᵳᵮᵸ, reason: contains not printable characters */
    public static List m6829(Iterable iterable) {
        if (iterable instanceof Collection) {
            return new ArrayList((Collection) iterable);
        }
        ArrayList arrayList = new ArrayList();
        m6831(iterable, arrayList);
        return arrayList;
    }

    /* renamed from: ᵴᵯᵴⁱ, reason: contains not printable characters */
    public static int[] m6830(ArrayList arrayList) {
        int[] iArr = new int[arrayList.size()];
        int size = arrayList.size();
        int i = 0;
        int i2 = 0;
        while (i2 < size) {
            Object obj = arrayList.get(i2);
            i2++;
            iArr[i] = ((Number) obj).intValue();
            i++;
        }
        return iArr;
    }

    /* renamed from: ᵷᵦﹳ, reason: contains not printable characters */
    public static final void m6831(Iterable iterable, AbstractCollection abstractCollection) {
        Iterator it = iterable.iterator();
        while (it.hasNext()) {
            abstractCollection.add(it.next());
        }
    }

    /* renamed from: ᵷᵱ, reason: contains not printable characters */
    public static final boolean m6832(List list, InterfaceC0362 interfaceC0362, boolean z) {
        int i;
        boolean z2 = false;
        if (!(list instanceof RandomAccess)) {
            if ((list instanceof InterfaceC3996) && !(list instanceof InterfaceC1867)) {
                ᵯˉˋ.ᐧﾞ(list, "kotlin.collections.MutableIterable");
                throw null;
            }
            Iterator it = list.iterator();
            while (it.hasNext()) {
                if (((Boolean) interfaceC0362.mo1588(it.next())).booleanValue() == z) {
                    it.remove();
                    z2 = true;
                }
            }
            return z2;
        }
        int iM5908 = AbstractC2240.m5908(list);
        if (iM5908 >= 0) {
            int i2 = 0;
            i = 0;
            while (true) {
                Object obj = list.get(i2);
                if (((Boolean) interfaceC0362.mo1588(obj)).booleanValue() != z) {
                    if (i != i2) {
                        list.set(i, obj);
                    }
                    i++;
                }
                if (i2 == iM5908) {
                    break;
                }
                i2++;
            }
        } else {
            i = 0;
        }
        if (i >= list.size()) {
            return false;
        }
        int iM59082 = AbstractC2240.m5908(list);
        if (i <= iM59082) {
            while (true) {
                list.remove(iM59082);
                if (iM59082 == i) {
                    break;
                }
                iM59082--;
            }
        }
        return true;
    }

    /* renamed from: ᵺᵜᵰ, reason: contains not printable characters */
    public static List m6833(Iterable iterable) {
        if (!(iterable instanceof Collection)) {
            List listM6829 = m6829(iterable);
            if (((ArrayList) listM6829).size() > 1) {
                Collections.sort(listM6829);
            }
            return listM6829;
        }
        Collection collection = (Collection) iterable;
        if (collection.size() <= 1) {
            return m6825(iterable);
        }
        Object[] array = collection.toArray(new Comparable[0]);
        Comparable[] comparableArr = (Comparable[]) array;
        if (comparableArr.length > 1) {
            Arrays.sort(comparableArr);
        }
        return Arrays.asList(array);
    }

    /* renamed from: ᵺᵠ, reason: contains not printable characters */
    public static Object m6834(Collection collection) {
        if (collection instanceof List) {
            List list = (List) collection;
            if (list.isEmpty()) {
                return null;
            }
            return list.get(0);
        }
        Iterator it = collection.iterator();
        if (it.hasNext()) {
            return it.next();
        }
        return null;
    }

    /* renamed from: ᵽʛ, reason: contains not printable characters */
    public static ArrayList m6835(Iterable iterable, int i) {
        Iterator it;
        AbstractC0494.m2169(i, i);
        if (!(iterable instanceof RandomAccess) || !(iterable instanceof List)) {
            ArrayList arrayList = new ArrayList();
            Iterator it2 = iterable.iterator();
            if (it2.hasNext()) {
                C2300 c2300 = new C2300(i, i, it2, null);
                C3625 c3625 = new C3625();
                c3625.f13512 = ᵱᵞᵪ.ᵝᵵᵺ(c3625, c3625, c2300);
                it = c3625;
            } else {
                it = C3856.f14334;
            }
            while (it.hasNext()) {
                arrayList.add((List) it.next());
            }
            return arrayList;
        }
        List list = (List) iterable;
        int size = list.size();
        ArrayList arrayList2 = new ArrayList((size / i) + (size % i == 0 ? 0 : 1));
        int i2 = 0;
        while (i2 >= 0 && i2 < size) {
            int i3 = size - i2;
            if (i <= i3) {
                i3 = i;
            }
            ArrayList arrayList3 = new ArrayList(i3);
            for (int i4 = 0; i4 < i3; i4++) {
                arrayList3.add(list.get(i4 + i2));
            }
            arrayList2.add(arrayList3);
            i2 += i;
        }
        return arrayList2;
    }

    /* renamed from: ﹶـ, reason: contains not printable characters */
    public static final void m6836(Iterable iterable, StringBuilder sb, CharSequence charSequence, CharSequence charSequence2, CharSequence charSequence3, CharSequence charSequence4, InterfaceC0362 interfaceC0362) {
        sb.append(charSequence2);
        int i = 0;
        for (Object obj : iterable) {
            i++;
            if (i > 1) {
                sb.append(charSequence);
            }
            ˉᵜˆ.ᵴᵳ(sb, obj, interfaceC0362);
        }
        sb.append(charSequence3);
    }
}