package g.c0;

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

/* JADX INFO: compiled from: ArrayDeque.kt */
/* JADX INFO: loaded from: classes.dex */
@g.i
public final class e<E> extends c<E> {

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    public static final Object[] f4061b = new Object[0];

    /* JADX INFO: renamed from: e, reason: collision with root package name */
    public int f4062e;

    /* JADX INFO: renamed from: f, reason: collision with root package name */
    public Object[] f4063f = f4061b;

    /* JADX INFO: renamed from: g, reason: collision with root package name */
    public int f4064g;

    @Override // java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
    public boolean add(E e2) {
        b(e2);
        return true;
    }

    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
    public boolean addAll(Collection<? extends E> collection) {
        g.h0.c.l.f(collection, "elements");
        if (collection.isEmpty()) {
            return false;
        }
        e(collection.size() + size());
        c(h(size() + this.f4062e), collection);
        return true;
    }

    public final void b(E e2) {
        e(size() + 1);
        this.f4063f[h(size() + this.f4062e)] = e2;
        this.f4064g = size() + 1;
    }

    public final void c(int i2, Collection<? extends E> collection) {
        Iterator<? extends E> it = collection.iterator();
        int length = this.f4063f.length;
        while (i2 < length && it.hasNext()) {
            this.f4063f[i2] = it.next();
            i2++;
        }
        int i3 = this.f4062e;
        for (int i4 = 0; i4 < i3 && it.hasNext(); i4++) {
            this.f4063f[i4] = it.next();
        }
        this.f4064g = collection.size() + size();
    }

    @Override // java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
    public void clear() {
        int iH = h(size() + this.f4062e);
        int i2 = this.f4062e;
        if (i2 < iH) {
            g.j(this.f4063f, null, i2, iH);
        } else if (!isEmpty()) {
            Object[] objArr = this.f4063f;
            g.j(objArr, null, this.f4062e, objArr.length);
            g.j(this.f4063f, null, 0, iH);
        }
        this.f4062e = 0;
        this.f4064g = 0;
    }

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

    public final int d(int i2) {
        return i2 == 0 ? f.a.y.a.f0(this.f4063f) : i2 - 1;
    }

    public final void e(int i2) {
        if (i2 < 0) {
            throw new IllegalStateException("Deque is too big.");
        }
        Object[] objArr = this.f4063f;
        if (i2 <= objArr.length) {
            return;
        }
        if (objArr == f4061b) {
            if (i2 < 10) {
                i2 = 10;
            }
            this.f4063f = new Object[i2];
            return;
        }
        int length = objArr.length;
        int i3 = length + (length >> 1);
        if (i3 - i2 < 0) {
            i3 = i2;
        }
        if (i3 - 2147483639 > 0) {
            i3 = i2 > 2147483639 ? Integer.MAX_VALUE : 2147483639;
        }
        Object[] objArr2 = new Object[i3];
        g.e(objArr, objArr2, 0, this.f4062e, objArr.length);
        Object[] objArr3 = this.f4063f;
        int length2 = objArr3.length;
        int i4 = this.f4062e;
        g.e(objArr3, objArr2, length2 - i4, 0, i4);
        this.f4062e = 0;
        this.f4063f = objArr2;
    }

    public final int f(int i2) {
        if (i2 == f.a.y.a.f0(this.f4063f)) {
            return 0;
        }
        return i2 + 1;
    }

    public final int g(int i2) {
        return i2 < 0 ? i2 + this.f4063f.length : i2;
    }

    @Override // java.util.AbstractList, java.util.List
    public E get(int i2) {
        int size = size();
        if (i2 < 0 || i2 >= size) {
            throw new IndexOutOfBoundsException(d.b.a.a.a.k("index: ", i2, ", size: ", size));
        }
        return (E) this.f4063f[h(this.f4062e + i2)];
    }

    public final int h(int i2) {
        Object[] objArr = this.f4063f;
        return i2 >= objArr.length ? i2 - objArr.length : i2;
    }

    public final E i() {
        if (isEmpty()) {
            throw new NoSuchElementException("ArrayDeque is empty.");
        }
        int iH = h(g.m(this) + this.f4062e);
        Object[] objArr = this.f4063f;
        E e2 = (E) objArr[iH];
        objArr[iH] = null;
        this.f4064g = size() - 1;
        return e2;
    }

    @Override // java.util.AbstractList, java.util.List
    public int indexOf(Object obj) {
        int i2;
        int iH = h(size() + this.f4062e);
        int length = this.f4062e;
        if (length < iH) {
            while (length < iH) {
                if (g.h0.c.l.a(obj, this.f4063f[length])) {
                    i2 = this.f4062e;
                } else {
                    length++;
                }
            }
            return -1;
        }
        if (length < iH) {
            return -1;
        }
        int length2 = this.f4063f.length;
        while (true) {
            if (length >= length2) {
                for (int i3 = 0; i3 < iH; i3++) {
                    if (g.h0.c.l.a(obj, this.f4063f[i3])) {
                        length = i3 + this.f4063f.length;
                        i2 = this.f4062e;
                    }
                }
                return -1;
            }
            if (g.h0.c.l.a(obj, this.f4063f[length])) {
                i2 = this.f4062e;
                break;
            }
            length++;
        }
        return length - i2;
    }

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

    @Override // java.util.AbstractList, java.util.List
    public int lastIndexOf(Object obj) {
        int iF0;
        int i2;
        int iH = h(size() + this.f4062e);
        int i3 = this.f4062e;
        if (i3 < iH) {
            iF0 = iH - 1;
            if (i3 <= iF0) {
                while (!g.h0.c.l.a(obj, this.f4063f[iF0])) {
                    if (iF0 != i3) {
                        iF0--;
                    }
                }
                i2 = this.f4062e;
                return iF0 - i2;
            }
            return -1;
        }
        if (i3 > iH) {
            int i4 = iH - 1;
            while (true) {
                if (-1 >= i4) {
                    iF0 = f.a.y.a.f0(this.f4063f);
                    int i5 = this.f4062e;
                    if (i5 <= iF0) {
                        while (!g.h0.c.l.a(obj, this.f4063f[iF0])) {
                            if (iF0 != i5) {
                                iF0--;
                            }
                        }
                        i2 = this.f4062e;
                    }
                } else {
                    if (g.h0.c.l.a(obj, this.f4063f[i4])) {
                        iF0 = i4 + this.f4063f.length;
                        i2 = this.f4062e;
                        break;
                    }
                    i4--;
                }
            }
        }
        return -1;
    }

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

    /* JADX WARN: Multi-variable type inference failed */
    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
    public boolean removeAll(Collection<? extends Object> collection) {
        int iH;
        g.h0.c.l.f(collection, "elements");
        boolean z = false;
        z = false;
        z = false;
        if (!isEmpty()) {
            if ((this.f4063f.length == 0) == false) {
                int iH2 = h(size() + this.f4062e);
                int i2 = this.f4062e;
                if (i2 < iH2) {
                    iH = i2;
                    while (i2 < iH2) {
                        Object obj = this.f4063f[i2];
                        if (!collection.contains(obj)) {
                            this.f4063f[iH] = obj;
                            iH++;
                        } else {
                            z = true;
                        }
                        i2++;
                    }
                    g.j(this.f4063f, null, iH, iH2);
                } else {
                    int length = this.f4063f.length;
                    boolean z2 = false;
                    int i3 = i2;
                    while (i2 < length) {
                        Object[] objArr = this.f4063f;
                        Object obj2 = objArr[i2];
                        objArr[i2] = null;
                        if (!collection.contains(obj2)) {
                            this.f4063f[i3] = obj2;
                            i3++;
                        } else {
                            z2 = true;
                        }
                        i2++;
                    }
                    iH = h(i3);
                    for (int i4 = 0; i4 < iH2; i4++) {
                        Object[] objArr2 = this.f4063f;
                        Object obj3 = objArr2[i4];
                        objArr2[i4] = null;
                        if (!collection.contains(obj3)) {
                            this.f4063f[iH] = obj3;
                            iH = f(iH);
                        } else {
                            z2 = true;
                        }
                    }
                    z = z2;
                }
                if (z) {
                    this.f4064g = g(iH - this.f4062e);
                }
            }
        }
        return z;
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
    public boolean retainAll(Collection<? extends Object> collection) {
        int iH;
        g.h0.c.l.f(collection, "elements");
        boolean z = false;
        z = false;
        z = false;
        if (!isEmpty()) {
            if ((this.f4063f.length == 0) == false) {
                int iH2 = h(size() + this.f4062e);
                int i2 = this.f4062e;
                if (i2 < iH2) {
                    iH = i2;
                    while (i2 < iH2) {
                        Object obj = this.f4063f[i2];
                        if (collection.contains(obj)) {
                            this.f4063f[iH] = obj;
                            iH++;
                        } else {
                            z = true;
                        }
                        i2++;
                    }
                    g.j(this.f4063f, null, iH, iH2);
                } else {
                    int length = this.f4063f.length;
                    boolean z2 = false;
                    int i3 = i2;
                    while (i2 < length) {
                        Object[] objArr = this.f4063f;
                        Object obj2 = objArr[i2];
                        objArr[i2] = null;
                        if (collection.contains(obj2)) {
                            this.f4063f[i3] = obj2;
                            i3++;
                        } else {
                            z2 = true;
                        }
                        i2++;
                    }
                    iH = h(i3);
                    for (int i4 = 0; i4 < iH2; i4++) {
                        Object[] objArr2 = this.f4063f;
                        Object obj3 = objArr2[i4];
                        objArr2[i4] = null;
                        if (collection.contains(obj3)) {
                            this.f4063f[iH] = obj3;
                            iH = f(iH);
                        } else {
                            z2 = true;
                        }
                    }
                    z = z2;
                }
                if (z) {
                    this.f4064g = g(iH - this.f4062e);
                }
            }
        }
        return z;
    }

    @Override // java.util.AbstractList, java.util.List
    public E set(int i2, E e2) {
        int size = size();
        if (i2 < 0 || i2 >= size) {
            throw new IndexOutOfBoundsException(d.b.a.a.a.k("index: ", i2, ", size: ", size));
        }
        int iH = h(this.f4062e + i2);
        Object[] objArr = this.f4063f;
        E e3 = (E) objArr[iH];
        objArr[iH] = e2;
        return e3;
    }

    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
    public <T> T[] toArray(T[] tArr) {
        g.h0.c.l.f(tArr, "array");
        if (tArr.length < size()) {
            int size = size();
            g.h0.c.l.f(tArr, "reference");
            Object objNewInstance = Array.newInstance(tArr.getClass().getComponentType(), size);
            g.h0.c.l.d(objNewInstance, "null cannot be cast to non-null type kotlin.Array<T of kotlin.collections.ArraysKt__ArraysJVMKt.arrayOfNulls>");
            tArr = (T[]) ((Object[]) objNewInstance);
        }
        int iH = h(size() + this.f4062e);
        int i2 = this.f4062e;
        if (i2 < iH) {
            g.g(this.f4063f, tArr, 0, i2, iH, 2);
        } else if (!isEmpty()) {
            Object[] objArr = this.f4063f;
            g.e(objArr, tArr, 0, this.f4062e, objArr.length);
            Object[] objArr2 = this.f4063f;
            g.e(objArr2, tArr, objArr2.length - this.f4062e, 0, iH);
        }
        if (tArr.length > size()) {
            tArr[size()] = null;
        }
        return tArr;
    }

    @Override // java.util.AbstractList, java.util.List
    public void add(int i2, E e2) {
        int size = size();
        if (i2 < 0 || i2 > size) {
            throw new IndexOutOfBoundsException(d.b.a.a.a.k("index: ", i2, ", size: ", size));
        }
        if (i2 == size()) {
            b(e2);
            return;
        }
        if (i2 == 0) {
            e(size() + 1);
            int iD = d(this.f4062e);
            this.f4062e = iD;
            this.f4063f[iD] = e2;
            this.f4064g = size() + 1;
            return;
        }
        e(size() + 1);
        int iH = h(this.f4062e + i2);
        if (i2 < ((size() + 1) >> 1)) {
            int iD2 = d(iH);
            int iD3 = d(this.f4062e);
            int i3 = this.f4062e;
            if (iD2 >= i3) {
                Object[] objArr = this.f4063f;
                objArr[iD3] = objArr[i3];
                g.e(objArr, objArr, i3, i3 + 1, iD2 + 1);
            } else {
                Object[] objArr2 = this.f4063f;
                g.e(objArr2, objArr2, i3 - 1, i3, objArr2.length);
                Object[] objArr3 = this.f4063f;
                objArr3[objArr3.length - 1] = objArr3[0];
                g.e(objArr3, objArr3, 0, 1, iD2 + 1);
            }
            this.f4063f[iD2] = e2;
            this.f4062e = iD3;
        } else {
            int iH2 = h(size() + this.f4062e);
            if (iH < iH2) {
                Object[] objArr4 = this.f4063f;
                g.e(objArr4, objArr4, iH + 1, iH, iH2);
            } else {
                Object[] objArr5 = this.f4063f;
                g.e(objArr5, objArr5, 1, 0, iH2);
                Object[] objArr6 = this.f4063f;
                objArr6[0] = objArr6[objArr6.length - 1];
                g.e(objArr6, objArr6, iH + 1, iH, objArr6.length - 1);
            }
            this.f4063f[iH] = e2;
        }
        this.f4064g = size() + 1;
    }

    @Override // java.util.AbstractList, java.util.List
    public boolean addAll(int i2, Collection<? extends E> collection) {
        g.h0.c.l.f(collection, "elements");
        int size = size();
        if (i2 >= 0 && i2 <= size) {
            if (collection.isEmpty()) {
                return false;
            }
            if (i2 == size()) {
                return addAll(collection);
            }
            e(collection.size() + size());
            int iH = h(size() + this.f4062e);
            int iH2 = h(this.f4062e + i2);
            int size2 = collection.size();
            if (i2 < ((size() + 1) >> 1)) {
                int i3 = this.f4062e;
                int length = i3 - size2;
                if (iH2 < i3) {
                    Object[] objArr = this.f4063f;
                    g.e(objArr, objArr, length, i3, objArr.length);
                    if (size2 >= iH2) {
                        Object[] objArr2 = this.f4063f;
                        g.e(objArr2, objArr2, objArr2.length - size2, 0, iH2);
                    } else {
                        Object[] objArr3 = this.f4063f;
                        g.e(objArr3, objArr3, objArr3.length - size2, 0, size2);
                        Object[] objArr4 = this.f4063f;
                        g.e(objArr4, objArr4, 0, size2, iH2);
                    }
                } else if (length >= 0) {
                    Object[] objArr5 = this.f4063f;
                    g.e(objArr5, objArr5, length, i3, iH2);
                } else {
                    Object[] objArr6 = this.f4063f;
                    length += objArr6.length;
                    int i4 = iH2 - i3;
                    int length2 = objArr6.length - length;
                    if (length2 >= i4) {
                        g.e(objArr6, objArr6, length, i3, iH2);
                    } else {
                        g.e(objArr6, objArr6, length, i3, i3 + length2);
                        Object[] objArr7 = this.f4063f;
                        g.e(objArr7, objArr7, 0, this.f4062e + length2, iH2);
                    }
                }
                this.f4062e = length;
                c(g(iH2 - size2), collection);
            } else {
                int i5 = iH2 + size2;
                if (iH2 < iH) {
                    int i6 = size2 + iH;
                    Object[] objArr8 = this.f4063f;
                    if (i6 <= objArr8.length) {
                        g.e(objArr8, objArr8, i5, iH2, iH);
                    } else if (i5 >= objArr8.length) {
                        g.e(objArr8, objArr8, i5 - objArr8.length, iH2, iH);
                    } else {
                        int length3 = iH - (i6 - objArr8.length);
                        g.e(objArr8, objArr8, 0, length3, iH);
                        Object[] objArr9 = this.f4063f;
                        g.e(objArr9, objArr9, i5, iH2, length3);
                    }
                } else {
                    Object[] objArr10 = this.f4063f;
                    g.e(objArr10, objArr10, size2, 0, iH);
                    Object[] objArr11 = this.f4063f;
                    if (i5 >= objArr11.length) {
                        g.e(objArr11, objArr11, i5 - objArr11.length, iH2, objArr11.length);
                    } else {
                        g.e(objArr11, objArr11, 0, objArr11.length - size2, objArr11.length);
                        Object[] objArr12 = this.f4063f;
                        g.e(objArr12, objArr12, i5, iH2, objArr12.length - size2);
                    }
                }
                c(iH2, collection);
            }
            return true;
        }
        throw new IndexOutOfBoundsException(d.b.a.a.a.k("index: ", i2, ", size: ", size));
    }

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