package defpackage;

import java.lang.reflect.Array;
import java.util.AbstractList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.NoSuchElementException;

/* renamed from: ᵖᴵᵥ, reason: contains not printable characters */
/* loaded from: classes3.dex */
public final class C2366 extends AbstractC4100 {

    /* renamed from: ᵾᵬ, reason: contains not printable characters */
    public static final Object[] f9287 = new Object[0];

    /* renamed from: ᵢˇᵭ, reason: contains not printable characters */
    public Object[] f9288;

    /* renamed from: ᵧᵾˀˈ, reason: contains not printable characters */
    public int f9289;

    /* renamed from: ᵿʗᵝʽ, reason: contains not printable characters */
    public int f9290;

    public C2366() {
        this.f9288 = f9287;
    }

    public C2366(int i) {
        Object[] objArr;
        if (i == 0) {
            objArr = f9287;
        } else {
            if (i <= 0) {
                ᵹˉᵞ.ˌᵜᵹᵩ(AbstractC2990.m7313(i, "Illegal Capacity: "));
                throw null;
            }
            objArr = new Object[i];
        }
        this.f9288 = objArr;
    }

    @Override // java.util.AbstractList, java.util.List
    public final void add(int i, Object obj) {
        int i2 = this.f9290;
        if (i < 0 || i > i2) {
            C2585.m6491(AbstractC1327.m4091(i, i2, "index: ", ", size: "));
            return;
        }
        if (i == i2) {
            addLast(obj);
            return;
        }
        if (i == 0) {
            addFirst(obj);
            return;
        }
        m6137();
        m6133(this.f9290 + 1);
        int iM6136 = m6136(this.f9289 + i);
        int i3 = this.f9290;
        int i4 = (i3 + 1) >> 1;
        int i5 = this.f9289;
        if (i < i4) {
            int length = iM6136 == 0 ? this.f9288.length - 1 : iM6136 - 1;
            int length2 = i5 == 0 ? this.f9288.length - 1 : i5 - 1;
            Object[] objArr = this.f9288;
            if (length >= i5) {
                objArr[length2] = objArr[i5];
                AbstractC1658.m4726(i5, i5 + 1, length + 1, objArr, objArr);
            } else {
                AbstractC1658.m4726(i5 - 1, i5, objArr.length, objArr, objArr);
                Object[] objArr2 = this.f9288;
                objArr2[objArr2.length - 1] = objArr2[0];
                AbstractC1658.m4726(0, 1, length + 1, objArr2, objArr2);
            }
            this.f9288[length] = obj;
            this.f9289 = length2;
        } else {
            int iM61362 = m6136(i3 + i5);
            Object[] objArr3 = this.f9288;
            if (iM6136 < iM61362) {
                AbstractC1658.m4726(iM6136 + 1, iM6136, iM61362, objArr3, objArr3);
            } else {
                AbstractC1658.m4726(1, 0, iM61362, objArr3, objArr3);
                Object[] objArr4 = this.f9288;
                objArr4[0] = objArr4[objArr4.length - 1];
                AbstractC1658.m4726(iM6136 + 1, iM6136, objArr4.length - 1, objArr4, objArr4);
            }
            this.f9288[iM6136] = obj;
        }
        this.f9290++;
    }

    @Override // java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
    public final boolean add(Object obj) {
        addLast(obj);
        return true;
    }

    @Override // java.util.AbstractList, java.util.List
    public final boolean addAll(int i, Collection collection) {
        int i2 = this.f9290;
        if (i < 0 || i > i2) {
            C2585.m6491(AbstractC1327.m4091(i, i2, "index: ", ", size: "));
            return false;
        }
        if (collection.isEmpty()) {
            return false;
        }
        if (i == this.f9290) {
            return addAll(collection);
        }
        m6137();
        m6133(collection.size() + this.f9290);
        int iM6136 = m6136(this.f9290 + this.f9289);
        int iM61362 = m6136(this.f9289 + i);
        int size = collection.size();
        if (i >= ((this.f9290 + 1) >> 1)) {
            int i3 = iM61362 + size;
            Object[] objArr = this.f9288;
            if (iM61362 < iM6136) {
                int i4 = size + iM6136;
                if (i4 <= objArr.length) {
                    AbstractC1658.m4726(i3, iM61362, iM6136, objArr, objArr);
                } else if (i3 >= objArr.length) {
                    AbstractC1658.m4726(i3 - objArr.length, iM61362, iM6136, objArr, objArr);
                } else {
                    int length = iM6136 - (i4 - objArr.length);
                    AbstractC1658.m4726(0, length, iM6136, objArr, objArr);
                    Object[] objArr2 = this.f9288;
                    AbstractC1658.m4726(i3, iM61362, length, objArr2, objArr2);
                }
            } else {
                AbstractC1658.m4726(size, 0, iM6136, objArr, objArr);
                Object[] objArr3 = this.f9288;
                if (i3 >= objArr3.length) {
                    AbstractC1658.m4726(i3 - objArr3.length, iM61362, objArr3.length, objArr3, objArr3);
                } else {
                    AbstractC1658.m4726(0, objArr3.length - size, objArr3.length, objArr3, objArr3);
                    Object[] objArr4 = this.f9288;
                    AbstractC1658.m4726(i3, iM61362, objArr4.length - size, objArr4, objArr4);
                }
            }
            m6140(iM61362, collection);
            return true;
        }
        int i5 = this.f9289;
        int length2 = i5 - size;
        Object[] objArr5 = this.f9288;
        if (iM61362 < i5) {
            AbstractC1658.m4726(length2, i5, objArr5.length, objArr5, objArr5);
            Object[] objArr6 = this.f9288;
            if (size >= iM61362) {
                AbstractC1658.m4726(objArr6.length - size, 0, iM61362, objArr6, objArr6);
            } else {
                AbstractC1658.m4726(objArr6.length - size, 0, size, objArr6, objArr6);
                Object[] objArr7 = this.f9288;
                AbstractC1658.m4726(0, size, iM61362, objArr7, objArr7);
            }
        } else if (length2 >= 0) {
            AbstractC1658.m4726(length2, i5, iM61362, objArr5, objArr5);
        } else {
            length2 += objArr5.length;
            int i6 = iM61362 - i5;
            int length3 = objArr5.length - length2;
            if (length3 >= i6) {
                AbstractC1658.m4726(length2, i5, iM61362, objArr5, objArr5);
            } else {
                AbstractC1658.m4726(length2, i5, i5 + length3, objArr5, objArr5);
                Object[] objArr8 = this.f9288;
                AbstractC1658.m4726(0, this.f9289 + length3, iM61362, objArr8, objArr8);
            }
        }
        this.f9289 = length2;
        m6140(m6134(iM61362 - size), collection);
        return true;
    }

    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
    public final boolean addAll(Collection collection) {
        if (collection.isEmpty()) {
            return false;
        }
        m6137();
        m6133(collection.size() + mo1040());
        m6140(m6136(mo1040() + this.f9289), collection);
        return true;
    }

    public final void addFirst(Object obj) {
        m6137();
        m6133(this.f9290 + 1);
        int length = this.f9289;
        if (length == 0) {
            length = this.f9288.length;
        }
        int i = length - 1;
        this.f9289 = i;
        this.f9288[i] = obj;
        this.f9290++;
    }

    public final void addLast(Object obj) {
        m6137();
        m6133(mo1040() + 1);
        this.f9288[m6136(mo1040() + this.f9289)] = obj;
        this.f9290 = mo1040() + 1;
    }

    @Override // java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
    public final void clear() {
        if (!isEmpty()) {
            m6137();
            m6139(this.f9289, m6136(mo1040() + this.f9289));
        }
        this.f9289 = 0;
        this.f9290 = 0;
    }

    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
    public final boolean contains(Object obj) {
        return indexOf(obj) != -1;
    }

    @Override // java.util.AbstractList, java.util.List
    public final Object get(int i) {
        int iMo1040 = mo1040();
        if (i >= 0 && i < iMo1040) {
            return this.f9288[m6136(this.f9289 + i)];
        }
        C2585.m6491(AbstractC1327.m4091(i, iMo1040, "index: ", ", size: "));
        return null;
    }

    @Override // java.util.AbstractList, java.util.List
    public final int indexOf(Object obj) {
        int i;
        int iM6136 = m6136(mo1040() + this.f9289);
        int length = this.f9289;
        if (length < iM6136) {
            while (length < iM6136) {
                if (ᵲᵝᵪ.ᵹᵝᵶ(obj, this.f9288[length])) {
                    i = this.f9289;
                } else {
                    length++;
                }
            }
            return -1;
        }
        if (isEmpty() || (length = this.f9289) < iM6136) {
            return -1;
        }
        int length2 = this.f9288.length;
        while (true) {
            if (length >= length2) {
                for (int i2 = 0; i2 < iM6136; i2++) {
                    if (ᵲᵝᵪ.ᵹᵝᵶ(obj, this.f9288[i2])) {
                        length = i2 + this.f9288.length;
                        i = this.f9289;
                    }
                }
                return -1;
            }
            if (ᵲᵝᵪ.ᵹᵝᵶ(obj, this.f9288[length])) {
                i = this.f9289;
                break;
            }
            length++;
        }
        return length - i;
    }

    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
    public final boolean isEmpty() {
        return mo1040() == 0;
    }

    @Override // java.util.AbstractList, java.util.List
    public final int lastIndexOf(Object obj) {
        int length;
        int i;
        int iM6136 = m6136(mo1040() + this.f9289);
        int i2 = this.f9289;
        if (i2 < iM6136) {
            length = iM6136 - 1;
            if (i2 <= length) {
                while (!ᵲᵝᵪ.ᵹᵝᵶ(obj, this.f9288[length])) {
                    if (length != i2) {
                        length--;
                    }
                }
                i = this.f9289;
                return length - i;
            }
            return -1;
        }
        if (!isEmpty() && this.f9289 >= iM6136) {
            while (true) {
                iM6136--;
                Object[] objArr = this.f9288;
                if (-1 >= iM6136) {
                    length = objArr.length - 1;
                    int i3 = this.f9289;
                    if (i3 <= length) {
                        while (!ᵲᵝᵪ.ᵹᵝᵶ(obj, this.f9288[length])) {
                            if (length != i3) {
                                length--;
                            }
                        }
                        i = this.f9289;
                    }
                } else if (ᵲᵝᵪ.ᵹᵝᵶ(obj, objArr[iM6136])) {
                    length = iM6136 + this.f9288.length;
                    i = this.f9289;
                    break;
                }
            }
            return length - i;
        }
        return -1;
    }

    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
    public final boolean remove(Object obj) {
        int iIndexOf = indexOf(obj);
        if (iIndexOf == -1) {
            return false;
        }
        mo1038(iIndexOf);
        return true;
    }

    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
    public final boolean removeAll(Collection collection) {
        int iM6136;
        Object[] objArr;
        boolean z = false;
        z = false;
        z = false;
        if (!isEmpty() && this.f9288.length != 0) {
            int iM61362 = m6136(mo1040() + this.f9289);
            int i = this.f9289;
            if (i < iM61362) {
                iM6136 = i;
                while (true) {
                    objArr = this.f9288;
                    if (i >= iM61362) {
                        break;
                    }
                    Object obj = objArr[i];
                    if (collection.contains(obj)) {
                        z = true;
                    } else {
                        this.f9288[iM6136] = obj;
                        iM6136++;
                    }
                    i++;
                }
                Arrays.fill(objArr, iM6136, iM61362, (Object) null);
            } else {
                int length = this.f9288.length;
                boolean z2 = false;
                int i2 = i;
                while (i < length) {
                    Object[] objArr2 = this.f9288;
                    Object obj2 = objArr2[i];
                    objArr2[i] = null;
                    if (collection.contains(obj2)) {
                        z2 = true;
                    } else {
                        this.f9288[i2] = obj2;
                        i2++;
                    }
                    i++;
                }
                iM6136 = m6136(i2);
                for (int i3 = 0; i3 < iM61362; i3++) {
                    Object[] objArr3 = this.f9288;
                    Object obj3 = objArr3[i3];
                    objArr3[i3] = null;
                    if (collection.contains(obj3)) {
                        z2 = true;
                    } else {
                        this.f9288[iM6136] = obj3;
                        iM6136 = m6135(iM6136);
                    }
                }
                z = z2;
            }
            if (z) {
                m6137();
                this.f9290 = m6134(iM6136 - this.f9289);
            }
        }
        return z;
    }

    public final Object removeFirst() {
        if (isEmpty()) {
            throw new NoSuchElementException("ArrayDeque is empty.");
        }
        m6137();
        Object[] objArr = this.f9288;
        int i = this.f9289;
        Object obj = objArr[i];
        objArr[i] = null;
        this.f9289 = m6135(i);
        this.f9290 = mo1040() - 1;
        return obj;
    }

    public final Object removeLast() {
        if (isEmpty()) {
            throw new NoSuchElementException("ArrayDeque is empty.");
        }
        m6137();
        int iM6136 = m6136(AbstractC2240.m5908(this) + this.f9289);
        Object[] objArr = this.f9288;
        Object obj = objArr[iM6136];
        objArr[iM6136] = null;
        this.f9290 = mo1040() - 1;
        return obj;
    }

    @Override // java.util.AbstractList
    public final void removeRange(int i, int i2) {
        ᵺᵣᵬ.ᵴᵳ(i, i2, this.f9290);
        int i3 = i2 - i;
        if (i3 == 0) {
            return;
        }
        if (i3 == this.f9290) {
            clear();
            return;
        }
        if (i3 == 1) {
            mo1038(i);
            return;
        }
        m6137();
        int i4 = this.f9290 - i2;
        int i5 = this.f9289;
        if (i < i4) {
            int iM6136 = m6136((i - 1) + i5);
            int iM61362 = m6136(this.f9289 + (i2 - 1));
            while (i > 0) {
                int i6 = iM6136 + 1;
                int iMin = Math.min(i, Math.min(i6, iM61362 + 1));
                Object[] objArr = this.f9288;
                int i7 = iM61362 - iMin;
                int i8 = iM6136 - iMin;
                AbstractC1658.m4726(i7 + 1, i8 + 1, i6, objArr, objArr);
                iM6136 = m6134(i8);
                iM61362 = m6134(i7);
                i -= iMin;
            }
            int iM61363 = m6136(this.f9289 + i3);
            m6139(this.f9289, iM61363);
            this.f9289 = iM61363;
        } else {
            int iM61364 = m6136(i5 + i2);
            int iM61365 = m6136(this.f9289 + i);
            int i9 = this.f9290;
            while (true) {
                i9 -= i2;
                if (i9 <= 0) {
                    break;
                }
                Object[] objArr2 = this.f9288;
                i2 = Math.min(i9, Math.min(objArr2.length - iM61364, objArr2.length - iM61365));
                Object[] objArr3 = this.f9288;
                int i10 = iM61364 + i2;
                AbstractC1658.m4726(iM61365, iM61364, i10, objArr3, objArr3);
                iM61364 = m6136(i10);
                iM61365 = m6136(iM61365 + i2);
            }
            int iM61366 = m6136(this.f9290 + this.f9289);
            m6139(m6134(iM61366 - i3), iM61366);
        }
        this.f9290 -= i3;
    }

    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
    public final boolean retainAll(Collection collection) {
        int iM6136;
        Object[] objArr;
        boolean z = false;
        z = false;
        z = false;
        if (!isEmpty() && this.f9288.length != 0) {
            int iM61362 = m6136(mo1040() + this.f9289);
            int i = this.f9289;
            if (i < iM61362) {
                iM6136 = i;
                while (true) {
                    objArr = this.f9288;
                    if (i >= iM61362) {
                        break;
                    }
                    Object obj = objArr[i];
                    if (collection.contains(obj)) {
                        this.f9288[iM6136] = obj;
                        iM6136++;
                    } else {
                        z = true;
                    }
                    i++;
                }
                Arrays.fill(objArr, iM6136, iM61362, (Object) null);
            } else {
                int length = this.f9288.length;
                boolean z2 = false;
                int i2 = i;
                while (i < length) {
                    Object[] objArr2 = this.f9288;
                    Object obj2 = objArr2[i];
                    objArr2[i] = null;
                    if (collection.contains(obj2)) {
                        this.f9288[i2] = obj2;
                        i2++;
                    } else {
                        z2 = true;
                    }
                    i++;
                }
                iM6136 = m6136(i2);
                for (int i3 = 0; i3 < iM61362; i3++) {
                    Object[] objArr3 = this.f9288;
                    Object obj3 = objArr3[i3];
                    objArr3[i3] = null;
                    if (collection.contains(obj3)) {
                        this.f9288[iM6136] = obj3;
                        iM6136 = m6135(iM6136);
                    } else {
                        z2 = true;
                    }
                }
                z = z2;
            }
            if (z) {
                m6137();
                this.f9290 = m6134(iM6136 - this.f9289);
            }
        }
        return z;
    }

    @Override // java.util.AbstractList, java.util.List
    public final Object set(int i, Object obj) {
        int iMo1040 = mo1040();
        if (i < 0 || i >= iMo1040) {
            C2585.m6491(AbstractC1327.m4091(i, iMo1040, "index: ", ", size: "));
            return null;
        }
        int iM6136 = m6136(this.f9289 + i);
        Object[] objArr = this.f9288;
        Object obj2 = objArr[iM6136];
        objArr[iM6136] = obj;
        return obj2;
    }

    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
    public final Object[] toArray() {
        return toArray(new Object[mo1040()]);
    }

    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
    public final Object[] toArray(Object[] objArr) {
        int length = objArr.length;
        int i = this.f9290;
        if (length < i) {
            objArr = (Object[]) Array.newInstance(objArr.getClass().getComponentType(), i);
        }
        int iM6136 = m6136(this.f9290 + this.f9289);
        int i2 = this.f9289;
        if (i2 < iM6136) {
            AbstractC1658.m4723(i2, iM6136, 2, this.f9288, objArr);
        } else if (!isEmpty()) {
            Object[] objArr2 = this.f9288;
            AbstractC1658.m4726(0, this.f9289, objArr2.length, objArr2, objArr);
            Object[] objArr3 = this.f9288;
            AbstractC1658.m4726(objArr3.length - this.f9289, 0, iM6136, objArr3, objArr);
        }
        int i3 = this.f9290;
        if (i3 < objArr.length) {
            objArr[i3] = null;
        }
        return objArr;
    }

    /* renamed from: ˇʼʤˎ, reason: contains not printable characters */
    public final void m6133(int i) {
        if (i < 0) {
            ᵹˉᵞ.ᵳٴᵶ("Deque is too big.");
            return;
        }
        Object[] objArr = this.f9288;
        if (i <= objArr.length) {
            return;
        }
        if (objArr == f9287) {
            if (i < 10) {
                i = 10;
            }
            this.f9288 = new Object[i];
            return;
        }
        int length = objArr.length;
        int i2 = length + (length >> 1);
        if (i2 - i < 0) {
            i2 = i;
        }
        if (i2 - 2147483639 > 0) {
            i2 = i > 2147483639 ? Integer.MAX_VALUE : 2147483639;
        }
        Object[] objArr2 = new Object[i2];
        AbstractC1658.m4726(0, this.f9289, objArr.length, objArr, objArr2);
        Object[] objArr3 = this.f9288;
        int length2 = objArr3.length;
        int i3 = this.f9289;
        AbstractC1658.m4726(length2 - i3, 0, i3, objArr3, objArr2);
        this.f9289 = 0;
        this.f9288 = objArr2;
    }

    /* renamed from: ˎˏʜʾ, reason: contains not printable characters */
    public final int m6134(int i) {
        return i < 0 ? i + this.f9288.length : i;
    }

    /* renamed from: ˏˋٴ, reason: contains not printable characters */
    public final int m6135(int i) {
        if (i == this.f9288.length - 1) {
            return 0;
        }
        return i + 1;
    }

    @Override // defpackage.AbstractC4100
    /* renamed from: ˏᵙ */
    public final Object mo1038(int i) {
        int i2 = this.f9290;
        if (i < 0 || i >= i2) {
            C2585.m6491(AbstractC1327.m4091(i, i2, "index: ", ", size: "));
            return null;
        }
        if (i == AbstractC2240.m5908(this)) {
            return removeLast();
        }
        if (i == 0) {
            return removeFirst();
        }
        m6137();
        int iM6136 = m6136(this.f9289 + i);
        Object[] objArr = this.f9288;
        Object obj = objArr[iM6136];
        int i3 = this.f9290 >> 1;
        int i4 = this.f9289;
        if (i < i3) {
            if (iM6136 >= i4) {
                AbstractC1658.m4726(i4 + 1, i4, iM6136, objArr, objArr);
            } else {
                AbstractC1658.m4726(1, 0, iM6136, objArr, objArr);
                Object[] objArr2 = this.f9288;
                objArr2[0] = objArr2[objArr2.length - 1];
                int i5 = this.f9289;
                AbstractC1658.m4726(i5 + 1, i5, objArr2.length - 1, objArr2, objArr2);
            }
            Object[] objArr3 = this.f9288;
            int i6 = this.f9289;
            objArr3[i6] = null;
            this.f9289 = m6135(i6);
        } else {
            int iM61362 = m6136(AbstractC2240.m5908(this) + i4);
            Object[] objArr4 = this.f9288;
            if (iM6136 <= iM61362) {
                AbstractC1658.m4726(iM6136, iM6136 + 1, iM61362 + 1, objArr4, objArr4);
            } else {
                AbstractC1658.m4726(iM6136, iM6136 + 1, objArr4.length, objArr4, objArr4);
                Object[] objArr5 = this.f9288;
                objArr5[objArr5.length - 1] = objArr5[0];
                AbstractC1658.m4726(0, 1, iM61362 + 1, objArr5, objArr5);
            }
            this.f9288[iM61362] = null;
        }
        this.f9290--;
        return obj;
    }

    /* renamed from: ᵝᵵᵺ, reason: contains not printable characters */
    public final int m6136(int i) {
        Object[] objArr = this.f9288;
        return i >= objArr.length ? i - objArr.length : i;
    }

    @Override // defpackage.AbstractC4100
    /* renamed from: ᵴᵳ */
    public final int mo1040() {
        return this.f9290;
    }

    /* renamed from: ᵶᵷᵕ, reason: contains not printable characters */
    public final void m6137() {
        ((AbstractList) this).modCount++;
    }

    /* renamed from: ᵸˑ, reason: contains not printable characters */
    public final Object m6138() {
        if (isEmpty()) {
            return null;
        }
        return removeFirst();
    }

    /* renamed from: ᵹᵝᵶ, reason: contains not printable characters */
    public final void m6139(int i, int i2) {
        Object[] objArr = this.f9288;
        if (i < i2) {
            Arrays.fill(objArr, i, i2, (Object) null);
        } else {
            Arrays.fill(objArr, i, objArr.length, (Object) null);
            Arrays.fill(this.f9288, 0, i2, (Object) null);
        }
    }

    /* renamed from: ᵻᵢﹳᵰ, reason: contains not printable characters */
    public final void m6140(int i, Collection collection) {
        Iterator it = collection.iterator();
        int length = this.f9288.length;
        while (i < length && it.hasNext()) {
            this.f9288[i] = it.next();
            i++;
        }
        int i2 = this.f9289;
        for (int i3 = 0; i3 < i2 && it.hasNext(); i3++) {
            this.f9288[i3] = it.next();
        }
        this.f9290 = collection.size() + this.f9290;
    }
}