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;

/* JADX INFO: renamed from: ˆᵼᵷ, reason: contains not printable characters */
/* JADX INFO: loaded from: classes3.dex */
public final class C0920 extends AbstractC5474 {

    /* JADX INFO: renamed from: ᵨᵼⁱ, reason: contains not printable characters */
    public static final Object[] f4032 = new Object[0];

    /* JADX INFO: renamed from: ˌᴵ, reason: contains not printable characters */
    public int f4033;

    /* JADX INFO: renamed from: ᵔᵖᵹᵫ, reason: contains not printable characters */
    public int f4034;

    /* JADX INFO: renamed from: ᵜᵪʾ, reason: contains not printable characters */
    public Object[] f4035;

    public C0920() {
        this.f4035 = f4032;
    }

    public C0920(int i) {
        Object[] objArr;
        if (i == 0) {
            objArr = f4032;
        } else {
            if (i <= 0) {
                ᵕᵩʽᵲ.ᵮᵣᵗˈ(AbstractC2704.m6517(i, "Illegal Capacity: "));
                throw null;
            }
            objArr = new Object[i];
        }
        this.f4035 = objArr;
    }

    @Override // java.util.AbstractList, java.util.List
    public final void add(int i, Object obj) {
        int i2 = this.f4034;
        if (i < 0 || i > i2) {
            C1390.m3982(AbstractC3653.m8230(i, i2, "index: ", ", size: "));
            return;
        }
        if (i == i2) {
            addLast(obj);
            return;
        }
        if (i == 0) {
            addFirst(obj);
            return;
        }
        m3170();
        m3169(this.f4034 + 1);
        int iM3174 = m3174(this.f4033 + i);
        int i3 = this.f4034;
        int i4 = (i3 + 1) >> 1;
        int i5 = this.f4033;
        if (i < i4) {
            int length = iM3174 == 0 ? this.f4035.length - 1 : iM3174 - 1;
            int length2 = i5 == 0 ? this.f4035.length - 1 : i5 - 1;
            Object[] objArr = this.f4035;
            if (length >= i5) {
                objArr[length2] = objArr[i5];
                AbstractC3761.m8436(i5, i5 + 1, length + 1, objArr, objArr);
            } else {
                AbstractC3761.m8436(i5 - 1, i5, objArr.length, objArr, objArr);
                Object[] objArr2 = this.f4035;
                objArr2[objArr2.length - 1] = objArr2[0];
                AbstractC3761.m8436(0, 1, length + 1, objArr2, objArr2);
            }
            this.f4035[length] = obj;
            this.f4033 = length2;
        } else {
            int iM31742 = m3174(i3 + i5);
            Object[] objArr3 = this.f4035;
            if (iM3174 < iM31742) {
                AbstractC3761.m8436(iM3174 + 1, iM3174, iM31742, objArr3, objArr3);
            } else {
                AbstractC3761.m8436(1, 0, iM31742, objArr3, objArr3);
                Object[] objArr4 = this.f4035;
                objArr4[0] = objArr4[objArr4.length - 1];
                AbstractC3761.m8436(iM3174 + 1, iM3174, objArr4.length - 1, objArr4, objArr4);
            }
            this.f4035[iM3174] = obj;
        }
        this.f4034++;
    }

    @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.f4034;
        if (i < 0 || i > i2) {
            C1390.m3982(AbstractC3653.m8230(i, i2, "index: ", ", size: "));
            return false;
        }
        if (collection.isEmpty()) {
            return false;
        }
        if (i == this.f4034) {
            return addAll(collection);
        }
        m3170();
        m3169(collection.size() + this.f4034);
        int iM3174 = m3174(this.f4034 + this.f4033);
        int iM31742 = m3174(this.f4033 + i);
        int size = collection.size();
        if (i >= ((this.f4034 + 1) >> 1)) {
            int i3 = iM31742 + size;
            Object[] objArr = this.f4035;
            if (iM31742 < iM3174) {
                int i4 = size + iM3174;
                if (i4 <= objArr.length) {
                    AbstractC3761.m8436(i3, iM31742, iM3174, objArr, objArr);
                } else if (i3 >= objArr.length) {
                    AbstractC3761.m8436(i3 - objArr.length, iM31742, iM3174, objArr, objArr);
                } else {
                    int length = iM3174 - (i4 - objArr.length);
                    AbstractC3761.m8436(0, length, iM3174, objArr, objArr);
                    Object[] objArr2 = this.f4035;
                    AbstractC3761.m8436(i3, iM31742, length, objArr2, objArr2);
                }
            } else {
                AbstractC3761.m8436(size, 0, iM3174, objArr, objArr);
                Object[] objArr3 = this.f4035;
                if (i3 >= objArr3.length) {
                    AbstractC3761.m8436(i3 - objArr3.length, iM31742, objArr3.length, objArr3, objArr3);
                } else {
                    AbstractC3761.m8436(0, objArr3.length - size, objArr3.length, objArr3, objArr3);
                    Object[] objArr4 = this.f4035;
                    AbstractC3761.m8436(i3, iM31742, objArr4.length - size, objArr4, objArr4);
                }
            }
            m3173(iM31742, collection);
            return true;
        }
        int i5 = this.f4033;
        int length2 = i5 - size;
        Object[] objArr5 = this.f4035;
        if (iM31742 < i5) {
            AbstractC3761.m8436(length2, i5, objArr5.length, objArr5, objArr5);
            Object[] objArr6 = this.f4035;
            if (size >= iM31742) {
                AbstractC3761.m8436(objArr6.length - size, 0, iM31742, objArr6, objArr6);
            } else {
                AbstractC3761.m8436(objArr6.length - size, 0, size, objArr6, objArr6);
                Object[] objArr7 = this.f4035;
                AbstractC3761.m8436(0, size, iM31742, objArr7, objArr7);
            }
        } else if (length2 >= 0) {
            AbstractC3761.m8436(length2, i5, iM31742, objArr5, objArr5);
        } else {
            length2 += objArr5.length;
            int i6 = iM31742 - i5;
            int length3 = objArr5.length - length2;
            if (length3 >= i6) {
                AbstractC3761.m8436(length2, i5, iM31742, objArr5, objArr5);
            } else {
                AbstractC3761.m8436(length2, i5, i5 + length3, objArr5, objArr5);
                Object[] objArr8 = this.f4035;
                AbstractC3761.m8436(0, this.f4033 + length3, iM31742, objArr8, objArr8);
            }
        }
        this.f4033 = length2;
        m3173(m3171(iM31742 - 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;
        }
        m3170();
        m3169(collection.size() + mo3166());
        m3173(m3174(mo3166() + this.f4033), collection);
        return true;
    }

    public final void addFirst(Object obj) {
        m3170();
        m3169(this.f4034 + 1);
        int length = this.f4033;
        if (length == 0) {
            length = this.f4035.length;
        }
        int i = length - 1;
        this.f4033 = i;
        this.f4035[i] = obj;
        this.f4034++;
    }

    public final void addLast(Object obj) {
        m3170();
        m3169(mo3166() + 1);
        this.f4035[m3174(mo3166() + this.f4033)] = obj;
        this.f4034 = mo3166() + 1;
    }

    @Override // java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
    public final void clear() {
        if (!isEmpty()) {
            m3170();
            m3167(this.f4033, m3174(mo3166() + this.f4033));
        }
        this.f4033 = 0;
        this.f4034 = 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 iMo3166 = mo3166();
        if (i >= 0 && i < iMo3166) {
            return this.f4035[m3174(this.f4033 + i)];
        }
        C1390.m3982(AbstractC3653.m8230(i, iMo3166, "index: ", ", size: "));
        return null;
    }

    @Override // java.util.AbstractList, java.util.List
    public final int indexOf(Object obj) {
        int i;
        int iM3174 = m3174(mo3166() + this.f4033);
        int length = this.f4033;
        if (length < iM3174) {
            while (length < iM3174) {
                if (ᵥˈᵛ.ˊᵫᵗ(obj, this.f4035[length])) {
                    i = this.f4033;
                } else {
                    length++;
                }
            }
            return -1;
        }
        if (isEmpty() || (length = this.f4033) < iM3174) {
            return -1;
        }
        int length2 = this.f4035.length;
        while (true) {
            if (length >= length2) {
                for (int i2 = 0; i2 < iM3174; i2++) {
                    if (ᵥˈᵛ.ˊᵫᵗ(obj, this.f4035[i2])) {
                        length = i2 + this.f4035.length;
                        i = this.f4033;
                    }
                }
                return -1;
            }
            if (ᵥˈᵛ.ˊᵫᵗ(obj, this.f4035[length])) {
                i = this.f4033;
                break;
            }
            length++;
        }
        return length - i;
    }

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

    @Override // java.util.AbstractList, java.util.List
    public final int lastIndexOf(Object obj) {
        int length;
        int i;
        int iM3174 = m3174(mo3166() + this.f4033);
        int i2 = this.f4033;
        if (i2 < iM3174) {
            length = iM3174 - 1;
            if (i2 <= length) {
                while (!ᵥˈᵛ.ˊᵫᵗ(obj, this.f4035[length])) {
                    if (length != i2) {
                        length--;
                    }
                }
                i = this.f4033;
                return length - i;
            }
            return -1;
        }
        if (!isEmpty() && this.f4033 >= iM3174) {
            while (true) {
                iM3174--;
                Object[] objArr = this.f4035;
                if (-1 >= iM3174) {
                    length = objArr.length - 1;
                    int i3 = this.f4033;
                    if (i3 <= length) {
                        while (!ᵥˈᵛ.ˊᵫᵗ(obj, this.f4035[length])) {
                            if (length != i3) {
                                length--;
                            }
                        }
                        i = this.f4033;
                    }
                } else if (ᵥˈᵛ.ˊᵫᵗ(obj, objArr[iM3174])) {
                    length = iM3174 + this.f4035.length;
                    i = this.f4033;
                    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;
        }
        mo3168(iIndexOf);
        return true;
    }

    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
    public final boolean removeAll(Collection collection) {
        int iM3174;
        Object[] objArr;
        boolean z = false;
        z = false;
        z = false;
        if (!isEmpty() && this.f4035.length != 0) {
            int iM31742 = m3174(mo3166() + this.f4033);
            int i = this.f4033;
            if (i < iM31742) {
                iM3174 = i;
                while (true) {
                    objArr = this.f4035;
                    if (i >= iM31742) {
                        break;
                    }
                    Object obj = objArr[i];
                    if (collection.contains(obj)) {
                        z = true;
                    } else {
                        this.f4035[iM3174] = obj;
                        iM3174++;
                    }
                    i++;
                }
                Arrays.fill(objArr, iM3174, iM31742, (Object) null);
            } else {
                int length = this.f4035.length;
                boolean z2 = false;
                int i2 = i;
                while (i < length) {
                    Object[] objArr2 = this.f4035;
                    Object obj2 = objArr2[i];
                    objArr2[i] = null;
                    if (collection.contains(obj2)) {
                        z2 = true;
                    } else {
                        this.f4035[i2] = obj2;
                        i2++;
                    }
                    i++;
                }
                iM3174 = m3174(i2);
                for (int i3 = 0; i3 < iM31742; i3++) {
                    Object[] objArr3 = this.f4035;
                    Object obj3 = objArr3[i3];
                    objArr3[i3] = null;
                    if (collection.contains(obj3)) {
                        z2 = true;
                    } else {
                        this.f4035[iM3174] = obj3;
                        iM3174 = m3175(iM3174);
                    }
                }
                z = z2;
            }
            if (z) {
                m3170();
                this.f4034 = m3171(iM3174 - this.f4033);
            }
        }
        return z;
    }

    public final Object removeFirst() {
        if (isEmpty()) {
            throw new NoSuchElementException("ArrayDeque is empty.");
        }
        m3170();
        Object[] objArr = this.f4035;
        int i = this.f4033;
        Object obj = objArr[i];
        objArr[i] = null;
        this.f4033 = m3175(i);
        this.f4034 = mo3166() - 1;
        return obj;
    }

    public final Object removeLast() {
        if (isEmpty()) {
            throw new NoSuchElementException("ArrayDeque is empty.");
        }
        m3170();
        int iM3174 = m3174(AbstractC0892.m3128(this) + this.f4033);
        Object[] objArr = this.f4035;
        Object obj = objArr[iM3174];
        objArr[iM3174] = null;
        this.f4034 = mo3166() - 1;
        return obj;
    }

    @Override // java.util.AbstractList
    public final void removeRange(int i, int i2) {
        ᵟˌᵫ.ːˏᵟᵯ(i, i2, this.f4034);
        int i3 = i2 - i;
        if (i3 == 0) {
            return;
        }
        if (i3 == this.f4034) {
            clear();
            return;
        }
        if (i3 == 1) {
            mo3168(i);
            return;
        }
        m3170();
        int i4 = this.f4034 - i2;
        int i5 = this.f4033;
        if (i < i4) {
            int iM3174 = m3174((i - 1) + i5);
            int iM31742 = m3174(this.f4033 + (i2 - 1));
            while (i > 0) {
                int i6 = iM3174 + 1;
                int iMin = Math.min(i, Math.min(i6, iM31742 + 1));
                Object[] objArr = this.f4035;
                int i7 = iM31742 - iMin;
                int i8 = iM3174 - iMin;
                AbstractC3761.m8436(i7 + 1, i8 + 1, i6, objArr, objArr);
                iM3174 = m3171(i8);
                iM31742 = m3171(i7);
                i -= iMin;
            }
            int iM31743 = m3174(this.f4033 + i3);
            m3167(this.f4033, iM31743);
            this.f4033 = iM31743;
        } else {
            int iM31744 = m3174(i5 + i2);
            int iM31745 = m3174(this.f4033 + i);
            int i9 = this.f4034;
            while (true) {
                i9 -= i2;
                if (i9 <= 0) {
                    break;
                }
                Object[] objArr2 = this.f4035;
                i2 = Math.min(i9, Math.min(objArr2.length - iM31744, objArr2.length - iM31745));
                Object[] objArr3 = this.f4035;
                int i10 = iM31744 + i2;
                AbstractC3761.m8436(iM31745, iM31744, i10, objArr3, objArr3);
                iM31744 = m3174(i10);
                iM31745 = m3174(iM31745 + i2);
            }
            int iM31746 = m3174(this.f4034 + this.f4033);
            m3167(m3171(iM31746 - i3), iM31746);
        }
        this.f4034 -= i3;
    }

    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
    public final boolean retainAll(Collection collection) {
        int iM3174;
        Object[] objArr;
        boolean z = false;
        z = false;
        z = false;
        if (!isEmpty() && this.f4035.length != 0) {
            int iM31742 = m3174(mo3166() + this.f4033);
            int i = this.f4033;
            if (i < iM31742) {
                iM3174 = i;
                while (true) {
                    objArr = this.f4035;
                    if (i >= iM31742) {
                        break;
                    }
                    Object obj = objArr[i];
                    if (collection.contains(obj)) {
                        this.f4035[iM3174] = obj;
                        iM3174++;
                    } else {
                        z = true;
                    }
                    i++;
                }
                Arrays.fill(objArr, iM3174, iM31742, (Object) null);
            } else {
                int length = this.f4035.length;
                boolean z2 = false;
                int i2 = i;
                while (i < length) {
                    Object[] objArr2 = this.f4035;
                    Object obj2 = objArr2[i];
                    objArr2[i] = null;
                    if (collection.contains(obj2)) {
                        this.f4035[i2] = obj2;
                        i2++;
                    } else {
                        z2 = true;
                    }
                    i++;
                }
                iM3174 = m3174(i2);
                for (int i3 = 0; i3 < iM31742; i3++) {
                    Object[] objArr3 = this.f4035;
                    Object obj3 = objArr3[i3];
                    objArr3[i3] = null;
                    if (collection.contains(obj3)) {
                        this.f4035[iM3174] = obj3;
                        iM3174 = m3175(iM3174);
                    } else {
                        z2 = true;
                    }
                }
                z = z2;
            }
            if (z) {
                m3170();
                this.f4034 = m3171(iM3174 - this.f4033);
            }
        }
        return z;
    }

    @Override // java.util.AbstractList, java.util.List
    public final Object set(int i, Object obj) {
        int iMo3166 = mo3166();
        if (i < 0 || i >= iMo3166) {
            C1390.m3982(AbstractC3653.m8230(i, iMo3166, "index: ", ", size: "));
            return null;
        }
        int iM3174 = m3174(this.f4033 + i);
        Object[] objArr = this.f4035;
        Object obj2 = objArr[iM3174];
        objArr[iM3174] = obj;
        return obj2;
    }

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

    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
    public final Object[] toArray(Object[] objArr) {
        int length = objArr.length;
        int i = this.f4034;
        if (length < i) {
            objArr = (Object[]) Array.newInstance(objArr.getClass().getComponentType(), i);
        }
        int iM3174 = m3174(this.f4034 + this.f4033);
        int i2 = this.f4033;
        if (i2 < iM3174) {
            AbstractC3761.m8427(i2, iM3174, 2, this.f4035, objArr);
        } else if (!isEmpty()) {
            Object[] objArr2 = this.f4035;
            AbstractC3761.m8436(0, this.f4033, objArr2.length, objArr2, objArr);
            Object[] objArr3 = this.f4035;
            AbstractC3761.m8436(objArr3.length - this.f4033, 0, iM3174, objArr3, objArr);
        }
        int i3 = this.f4034;
        if (i3 < objArr.length) {
            objArr[i3] = null;
        }
        return objArr;
    }

    @Override // defpackage.AbstractC5474
    /* JADX INFO: renamed from: ʽˈˋ, reason: contains not printable characters */
    public final int mo3166() {
        return this.f4034;
    }

    /* JADX INFO: renamed from: ˊᵫᵗ, reason: contains not printable characters */
    public final void m3167(int i, int i2) {
        Object[] objArr = this.f4035;
        if (i < i2) {
            Arrays.fill(objArr, i, i2, (Object) null);
        } else {
            Arrays.fill(objArr, i, objArr.length, (Object) null);
            Arrays.fill(this.f4035, 0, i2, (Object) null);
        }
    }

    @Override // defpackage.AbstractC5474
    /* JADX INFO: renamed from: ːˏᵟᵯ, reason: contains not printable characters */
    public final Object mo3168(int i) {
        int i2 = this.f4034;
        if (i < 0 || i >= i2) {
            C1390.m3982(AbstractC3653.m8230(i, i2, "index: ", ", size: "));
            return null;
        }
        if (i == AbstractC0892.m3128(this)) {
            return removeLast();
        }
        if (i == 0) {
            return removeFirst();
        }
        m3170();
        int iM3174 = m3174(this.f4033 + i);
        Object[] objArr = this.f4035;
        Object obj = objArr[iM3174];
        int i3 = this.f4034 >> 1;
        int i4 = this.f4033;
        if (i < i3) {
            if (iM3174 >= i4) {
                AbstractC3761.m8436(i4 + 1, i4, iM3174, objArr, objArr);
            } else {
                AbstractC3761.m8436(1, 0, iM3174, objArr, objArr);
                Object[] objArr2 = this.f4035;
                objArr2[0] = objArr2[objArr2.length - 1];
                int i5 = this.f4033;
                AbstractC3761.m8436(i5 + 1, i5, objArr2.length - 1, objArr2, objArr2);
            }
            Object[] objArr3 = this.f4035;
            int i6 = this.f4033;
            objArr3[i6] = null;
            this.f4033 = m3175(i6);
        } else {
            int iM31742 = m3174(AbstractC0892.m3128(this) + i4);
            Object[] objArr4 = this.f4035;
            if (iM3174 <= iM31742) {
                AbstractC3761.m8436(iM3174, iM3174 + 1, iM31742 + 1, objArr4, objArr4);
            } else {
                AbstractC3761.m8436(iM3174, iM3174 + 1, objArr4.length, objArr4, objArr4);
                Object[] objArr5 = this.f4035;
                objArr5[objArr5.length - 1] = objArr5[0];
                AbstractC3761.m8436(0, 1, iM31742 + 1, objArr5, objArr5);
            }
            this.f4035[iM31742] = null;
        }
        this.f4034--;
        return obj;
    }

    /* JADX INFO: renamed from: ᵨᵣ, reason: contains not printable characters */
    public final void m3169(int i) {
        if (i < 0) {
            ᵕᵩʽᵲ.ᵪᵹᵥᵻ("Deque is too big.");
            return;
        }
        Object[] objArr = this.f4035;
        if (i <= objArr.length) {
            return;
        }
        if (objArr == f4032) {
            if (i < 10) {
                i = 10;
            }
            this.f4035 = 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];
        AbstractC3761.m8436(0, this.f4033, objArr.length, objArr, objArr2);
        Object[] objArr3 = this.f4035;
        int length2 = objArr3.length;
        int i3 = this.f4033;
        AbstractC3761.m8436(length2 - i3, 0, i3, objArr3, objArr2);
        this.f4033 = 0;
        this.f4035 = objArr2;
    }

    /* JADX INFO: renamed from: ᵱᵽʡᵚ, reason: contains not printable characters */
    public final void m3170() {
        ((AbstractList) this).modCount++;
    }

    /* JADX INFO: renamed from: ᵵᵽ, reason: contains not printable characters */
    public final int m3171(int i) {
        return i < 0 ? i + this.f4035.length : i;
    }

    /* JADX INFO: renamed from: ᵶᵥᵝ, reason: contains not printable characters */
    public final Object m3172() {
        if (isEmpty()) {
            return null;
        }
        return removeFirst();
    }

    /* JADX INFO: renamed from: ᵷᵺʾᵖ, reason: contains not printable characters */
    public final void m3173(int i, Collection collection) {
        Iterator it = collection.iterator();
        int length = this.f4035.length;
        while (i < length && it.hasNext()) {
            this.f4035[i] = it.next();
            i++;
        }
        int i2 = this.f4033;
        for (int i3 = 0; i3 < i2 && it.hasNext(); i3++) {
            this.f4035[i3] = it.next();
        }
        this.f4034 = collection.size() + this.f4034;
    }

    /* JADX INFO: renamed from: ᵻʽᵯ, reason: contains not printable characters */
    public final int m3174(int i) {
        Object[] objArr = this.f4035;
        return i >= objArr.length ? i - objArr.length : i;
    }

    /* JADX INFO: renamed from: ᵻˈᵦʼ, reason: contains not printable characters */
    public final int m3175(int i) {
        if (i == this.f4035.length - 1) {
            return 0;
        }
        return i + 1;
    }
}