package x4;

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: x4.o, reason: case insensitive filesystem */
/* JADX INFO: loaded from: classes3.dex */
public final class C3249o extends AbstractC3243i {

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

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

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    public Object[] f26062b;

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

    public C3249o() {
        this.f26062b = f26060d;
    }

    @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.AbstractCollection, java.util.Collection, java.util.List
    public final boolean addAll(Collection elements) {
        kotlin.jvm.internal.o.h(elements, "elements");
        if (elements.isEmpty()) {
            return false;
        }
        p();
        h(elements.size() + size());
        g(o(size() + this.f26061a), elements);
        return true;
    }

    public final void addFirst(Object obj) {
        p();
        h(size() + 1);
        int length = this.f26061a;
        if (length == 0) {
            Object[] objArr = this.f26062b;
            kotlin.jvm.internal.o.h(objArr, "<this>");
            length = objArr.length;
        }
        int i6 = length - 1;
        this.f26061a = i6;
        this.f26062b[i6] = obj;
        this.f26063c = size() + 1;
    }

    public final void addLast(Object obj) {
        p();
        h(size() + 1);
        this.f26062b[o(size() + this.f26061a)] = obj;
        this.f26063c = size() + 1;
    }

    @Override // java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
    public final void clear() {
        if (!isEmpty()) {
            p();
            n(this.f26061a, o(size() + this.f26061a));
        }
        this.f26061a = 0;
        this.f26063c = 0;
    }

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

    public final Object first() {
        if (isEmpty()) {
            throw new NoSuchElementException("ArrayDeque is empty.");
        }
        return this.f26062b[this.f26061a];
    }

    public final void g(int i6, Collection collection) {
        Iterator it = collection.iterator();
        int length = this.f26062b.length;
        while (i6 < length && it.hasNext()) {
            this.f26062b[i6] = it.next();
            i6++;
        }
        int i7 = this.f26061a;
        for (int i8 = 0; i8 < i7 && it.hasNext(); i8++) {
            this.f26062b[i8] = it.next();
        }
        this.f26063c = collection.size() + size();
    }

    @Override // java.util.AbstractList, java.util.List
    public final Object get(int i6) {
        C3236b c3236b = AbstractC3239e.Companion;
        int size = size();
        c3236b.getClass();
        C3236b.b(i6, size);
        return this.f26062b[o(this.f26061a + i6)];
    }

    @Override // x4.AbstractC3243i
    public final int getSize() {
        return this.f26063c;
    }

    public final void h(int i6) {
        if (i6 < 0) {
            throw new IllegalStateException("Deque is too big.");
        }
        Object[] objArr = this.f26062b;
        if (i6 <= objArr.length) {
            return;
        }
        if (objArr == f26060d) {
            if (i6 < 10) {
                i6 = 10;
            }
            this.f26062b = new Object[i6];
            return;
        }
        C3236b c3236b = AbstractC3239e.Companion;
        int length = objArr.length;
        c3236b.getClass();
        Object[] objArr2 = new Object[C3236b.e(length, i6)];
        Object[] objArr3 = this.f26062b;
        AbstractC3250p.B(objArr3, 0, objArr2, this.f26061a, objArr3.length);
        Object[] objArr4 = this.f26062b;
        int length2 = objArr4.length;
        int i7 = this.f26061a;
        AbstractC3250p.B(objArr4, length2 - i7, objArr2, 0, i7);
        this.f26061a = 0;
        this.f26062b = objArr2;
    }

    @Override // java.util.AbstractList, java.util.List
    public final int indexOf(Object obj) {
        int i6;
        int iO = o(size() + this.f26061a);
        int length = this.f26061a;
        if (length < iO) {
            while (length < iO) {
                if (kotlin.jvm.internal.o.c(obj, this.f26062b[length])) {
                    i6 = this.f26061a;
                } else {
                    length++;
                }
            }
            return -1;
        }
        if (length < iO) {
            return -1;
        }
        int length2 = this.f26062b.length;
        while (true) {
            if (length >= length2) {
                for (int i7 = 0; i7 < iO; i7++) {
                    if (kotlin.jvm.internal.o.c(obj, this.f26062b[i7])) {
                        length = i7 + this.f26062b.length;
                        i6 = this.f26061a;
                    }
                }
                return -1;
            }
            if (kotlin.jvm.internal.o.c(obj, this.f26062b[length])) {
                i6 = this.f26061a;
                break;
            }
            length++;
        }
        return length - i6;
    }

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

    public final Object j() {
        if (isEmpty()) {
            return null;
        }
        return this.f26062b[this.f26061a];
    }

    public final int k(int i6) {
        kotlin.jvm.internal.o.h(this.f26062b, "<this>");
        if (i6 == r0.length - 1) {
            return 0;
        }
        return i6 + 1;
    }

    public final Object l() {
        if (isEmpty()) {
            return null;
        }
        return this.f26062b[o(AbstractC3252r.A(this) + this.f26061a)];
    }

    public final Object last() {
        if (isEmpty()) {
            throw new NoSuchElementException("ArrayDeque is empty.");
        }
        return this.f26062b[o(AbstractC3252r.A(this) + this.f26061a)];
    }

    @Override // java.util.AbstractList, java.util.List
    public final int lastIndexOf(Object obj) {
        int length;
        int i6;
        int iO = o(size() + this.f26061a);
        int i7 = this.f26061a;
        if (i7 < iO) {
            length = iO - 1;
            if (i7 <= length) {
                while (!kotlin.jvm.internal.o.c(obj, this.f26062b[length])) {
                    if (length != i7) {
                        length--;
                    }
                }
                i6 = this.f26061a;
                return length - i6;
            }
            return -1;
        }
        if (i7 > iO) {
            int i8 = iO - 1;
            while (true) {
                if (-1 >= i8) {
                    Object[] objArr = this.f26062b;
                    kotlin.jvm.internal.o.h(objArr, "<this>");
                    length = objArr.length - 1;
                    int i9 = this.f26061a;
                    if (i9 <= length) {
                        while (!kotlin.jvm.internal.o.c(obj, this.f26062b[length])) {
                            if (length != i9) {
                                length--;
                            }
                        }
                        i6 = this.f26061a;
                    }
                } else {
                    if (kotlin.jvm.internal.o.c(obj, this.f26062b[i8])) {
                        length = i8 + this.f26062b.length;
                        i6 = this.f26061a;
                        break;
                    }
                    i8--;
                }
            }
        }
        return -1;
    }

    public final int m(int i6) {
        return i6 < 0 ? i6 + this.f26062b.length : i6;
    }

    public final void n(int i6, int i7) {
        if (i6 < i7) {
            AbstractC3250p.H(this.f26062b, null, i6, i7);
            return;
        }
        Object[] objArr = this.f26062b;
        Arrays.fill(objArr, i6, objArr.length, (Object) null);
        AbstractC3250p.H(this.f26062b, null, 0, i7);
    }

    public final int o(int i6) {
        Object[] objArr = this.f26062b;
        return i6 >= objArr.length ? i6 - objArr.length : i6;
    }

    public final void p() {
        ((AbstractList) this).modCount++;
    }

    @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;
        }
        remove(iIndexOf);
        return true;
    }

    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
    public final boolean removeAll(Collection elements) {
        int iO;
        kotlin.jvm.internal.o.h(elements, "elements");
        boolean z6 = false;
        z6 = false;
        z6 = false;
        if (!isEmpty() && this.f26062b.length != 0) {
            int iO2 = o(size() + this.f26061a);
            int i6 = this.f26061a;
            if (i6 < iO2) {
                iO = i6;
                while (i6 < iO2) {
                    Object obj = this.f26062b[i6];
                    if (elements.contains(obj)) {
                        z6 = true;
                    } else {
                        this.f26062b[iO] = obj;
                        iO++;
                    }
                    i6++;
                }
                AbstractC3250p.H(this.f26062b, null, iO, iO2);
            } else {
                int length = this.f26062b.length;
                boolean z7 = false;
                int i7 = i6;
                while (i6 < length) {
                    Object[] objArr = this.f26062b;
                    Object obj2 = objArr[i6];
                    objArr[i6] = null;
                    if (elements.contains(obj2)) {
                        z7 = true;
                    } else {
                        this.f26062b[i7] = obj2;
                        i7++;
                    }
                    i6++;
                }
                iO = o(i7);
                for (int i8 = 0; i8 < iO2; i8++) {
                    Object[] objArr2 = this.f26062b;
                    Object obj3 = objArr2[i8];
                    objArr2[i8] = null;
                    if (elements.contains(obj3)) {
                        z7 = true;
                    } else {
                        this.f26062b[iO] = obj3;
                        iO = k(iO);
                    }
                }
                z6 = z7;
            }
            if (z6) {
                p();
                this.f26063c = m(iO - this.f26061a);
            }
        }
        return z6;
    }

    @Override // x4.AbstractC3243i
    public final Object removeAt(int i6) {
        C3236b c3236b = AbstractC3239e.Companion;
        int size = size();
        c3236b.getClass();
        C3236b.b(i6, size);
        if (i6 == AbstractC3252r.A(this)) {
            return removeLast();
        }
        if (i6 == 0) {
            return removeFirst();
        }
        p();
        int iO = o(this.f26061a + i6);
        Object obj = this.f26062b[iO];
        if (i6 < (size() >> 1)) {
            int i7 = this.f26061a;
            if (iO >= i7) {
                Object[] objArr = this.f26062b;
                AbstractC3250p.B(objArr, i7 + 1, objArr, i7, iO);
            } else {
                Object[] objArr2 = this.f26062b;
                AbstractC3250p.B(objArr2, 1, objArr2, 0, iO);
                Object[] objArr3 = this.f26062b;
                objArr3[0] = objArr3[objArr3.length - 1];
                int i8 = this.f26061a;
                AbstractC3250p.B(objArr3, i8 + 1, objArr3, i8, objArr3.length - 1);
            }
            Object[] objArr4 = this.f26062b;
            int i9 = this.f26061a;
            objArr4[i9] = null;
            this.f26061a = k(i9);
        } else {
            int iO2 = o(AbstractC3252r.A(this) + this.f26061a);
            if (iO <= iO2) {
                Object[] objArr5 = this.f26062b;
                AbstractC3250p.B(objArr5, iO, objArr5, iO + 1, iO2 + 1);
            } else {
                Object[] objArr6 = this.f26062b;
                AbstractC3250p.B(objArr6, iO, objArr6, iO + 1, objArr6.length);
                Object[] objArr7 = this.f26062b;
                objArr7[objArr7.length - 1] = objArr7[0];
                AbstractC3250p.B(objArr7, 0, objArr7, 1, iO2 + 1);
            }
            this.f26062b[iO2] = null;
        }
        this.f26063c = size() - 1;
        return obj;
    }

    public final Object removeFirst() {
        if (isEmpty()) {
            throw new NoSuchElementException("ArrayDeque is empty.");
        }
        p();
        Object[] objArr = this.f26062b;
        int i6 = this.f26061a;
        Object obj = objArr[i6];
        objArr[i6] = null;
        this.f26061a = k(i6);
        this.f26063c = size() - 1;
        return obj;
    }

    public final Object removeLast() {
        if (isEmpty()) {
            throw new NoSuchElementException("ArrayDeque is empty.");
        }
        p();
        int iO = o(AbstractC3252r.A(this) + this.f26061a);
        Object[] objArr = this.f26062b;
        Object obj = objArr[iO];
        objArr[iO] = null;
        this.f26063c = size() - 1;
        return obj;
    }

    @Override // java.util.AbstractList
    public final void removeRange(int i6, int i7) {
        C3236b c3236b = AbstractC3239e.Companion;
        int size = size();
        c3236b.getClass();
        C3236b.d(i6, i7, size);
        int i8 = i7 - i6;
        if (i8 == 0) {
            return;
        }
        if (i8 == size()) {
            clear();
            return;
        }
        if (i8 == 1) {
            remove(i6);
            return;
        }
        p();
        if (i6 < size() - i7) {
            int iO = o((i6 - 1) + this.f26061a);
            int iO2 = o((i7 - 1) + this.f26061a);
            while (i6 > 0) {
                int i9 = iO + 1;
                int iMin = Math.min(i6, Math.min(i9, iO2 + 1));
                Object[] objArr = this.f26062b;
                int i10 = iO2 - iMin;
                int i11 = iO - iMin;
                AbstractC3250p.B(objArr, i10 + 1, objArr, i11 + 1, i9);
                iO = m(i11);
                iO2 = m(i10);
                i6 -= iMin;
            }
            int iO3 = o(this.f26061a + i8);
            n(this.f26061a, iO3);
            this.f26061a = iO3;
        } else {
            int iO4 = o(this.f26061a + i7);
            int iO5 = o(this.f26061a + i6);
            int size2 = size();
            while (true) {
                size2 -= i7;
                if (size2 <= 0) {
                    break;
                }
                Object[] objArr2 = this.f26062b;
                i7 = Math.min(size2, Math.min(objArr2.length - iO4, objArr2.length - iO5));
                Object[] objArr3 = this.f26062b;
                int i12 = iO4 + i7;
                AbstractC3250p.B(objArr3, iO5, objArr3, iO4, i12);
                iO4 = o(i12);
                iO5 = o(iO5 + i7);
            }
            int iO6 = o(size() + this.f26061a);
            n(m(iO6 - i8), iO6);
        }
        this.f26063c = size() - i8;
    }

    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
    public final boolean retainAll(Collection elements) {
        int iO;
        kotlin.jvm.internal.o.h(elements, "elements");
        boolean z6 = false;
        z6 = false;
        z6 = false;
        if (!isEmpty() && this.f26062b.length != 0) {
            int iO2 = o(size() + this.f26061a);
            int i6 = this.f26061a;
            if (i6 < iO2) {
                iO = i6;
                while (i6 < iO2) {
                    Object obj = this.f26062b[i6];
                    if (elements.contains(obj)) {
                        this.f26062b[iO] = obj;
                        iO++;
                    } else {
                        z6 = true;
                    }
                    i6++;
                }
                AbstractC3250p.H(this.f26062b, null, iO, iO2);
            } else {
                int length = this.f26062b.length;
                boolean z7 = false;
                int i7 = i6;
                while (i6 < length) {
                    Object[] objArr = this.f26062b;
                    Object obj2 = objArr[i6];
                    objArr[i6] = null;
                    if (elements.contains(obj2)) {
                        this.f26062b[i7] = obj2;
                        i7++;
                    } else {
                        z7 = true;
                    }
                    i6++;
                }
                iO = o(i7);
                for (int i8 = 0; i8 < iO2; i8++) {
                    Object[] objArr2 = this.f26062b;
                    Object obj3 = objArr2[i8];
                    objArr2[i8] = null;
                    if (elements.contains(obj3)) {
                        this.f26062b[iO] = obj3;
                        iO = k(iO);
                    } else {
                        z7 = true;
                    }
                }
                z6 = z7;
            }
            if (z6) {
                p();
                this.f26063c = m(iO - this.f26061a);
            }
        }
        return z6;
    }

    @Override // java.util.AbstractList, java.util.List
    public final Object set(int i6, Object obj) {
        C3236b c3236b = AbstractC3239e.Companion;
        int size = size();
        c3236b.getClass();
        C3236b.b(i6, size);
        int iO = o(this.f26061a + i6);
        Object[] objArr = this.f26062b;
        Object obj2 = objArr[iO];
        objArr[iO] = obj;
        return obj2;
    }

    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
    public final Object[] toArray(Object[] array) {
        kotlin.jvm.internal.o.h(array, "array");
        if (array.length < size()) {
            Object objNewInstance = Array.newInstance(array.getClass().getComponentType(), size());
            kotlin.jvm.internal.o.f(objNewInstance, "null cannot be cast to non-null type kotlin.Array<T of kotlin.collections.ArraysKt__ArraysJVMKt.arrayOfNulls>");
            array = (Object[]) objNewInstance;
        }
        int iO = o(size() + this.f26061a);
        int i6 = this.f26061a;
        if (i6 < iO) {
            AbstractC3250p.E(this.f26062b, i6, array, iO, 2);
        } else if (!isEmpty()) {
            Object[] objArr = this.f26062b;
            AbstractC3250p.B(objArr, 0, array, this.f26061a, objArr.length);
            Object[] objArr2 = this.f26062b;
            AbstractC3250p.B(objArr2, objArr2.length - this.f26061a, array, 0, iO);
        }
        int size = size();
        if (size < array.length) {
            array[size] = null;
        }
        return array;
    }

    @Override // java.util.AbstractList, java.util.List
    public final void add(int i6, Object obj) {
        int length;
        C3236b c3236b = AbstractC3239e.Companion;
        int size = size();
        c3236b.getClass();
        C3236b.c(i6, size);
        if (i6 == size()) {
            addLast(obj);
            return;
        }
        if (i6 == 0) {
            addFirst(obj);
            return;
        }
        p();
        h(size() + 1);
        int iO = o(this.f26061a + i6);
        if (i6 < ((size() + 1) >> 1)) {
            if (iO == 0) {
                Object[] objArr = this.f26062b;
                kotlin.jvm.internal.o.h(objArr, "<this>");
                iO = objArr.length;
            }
            int i7 = iO - 1;
            int i8 = this.f26061a;
            if (i8 == 0) {
                Object[] objArr2 = this.f26062b;
                kotlin.jvm.internal.o.h(objArr2, "<this>");
                length = objArr2.length - 1;
            } else {
                length = i8 - 1;
            }
            int i9 = this.f26061a;
            if (i7 >= i9) {
                Object[] objArr3 = this.f26062b;
                objArr3[length] = objArr3[i9];
                AbstractC3250p.B(objArr3, i9, objArr3, i9 + 1, i7 + 1);
            } else {
                Object[] objArr4 = this.f26062b;
                AbstractC3250p.B(objArr4, i9 - 1, objArr4, i9, objArr4.length);
                Object[] objArr5 = this.f26062b;
                objArr5[objArr5.length - 1] = objArr5[0];
                AbstractC3250p.B(objArr5, 0, objArr5, 1, i7 + 1);
            }
            this.f26062b[i7] = obj;
            this.f26061a = length;
        } else {
            int iO2 = o(size() + this.f26061a);
            if (iO < iO2) {
                Object[] objArr6 = this.f26062b;
                AbstractC3250p.B(objArr6, iO + 1, objArr6, iO, iO2);
            } else {
                Object[] objArr7 = this.f26062b;
                AbstractC3250p.B(objArr7, 1, objArr7, 0, iO2);
                Object[] objArr8 = this.f26062b;
                objArr8[0] = objArr8[objArr8.length - 1];
                AbstractC3250p.B(objArr8, iO + 1, objArr8, iO, objArr8.length - 1);
            }
            this.f26062b[iO] = obj;
        }
        this.f26063c = size() + 1;
    }

    public C3249o(int i6) {
        Object[] objArr;
        if (i6 == 0) {
            objArr = f26060d;
        } else if (i6 > 0) {
            objArr = new Object[i6];
        } else {
            throw new IllegalArgumentException(Z0.o.l("Illegal Capacity: ", i6));
        }
        this.f26062b = objArr;
    }

    @Override // java.util.AbstractList, java.util.List
    public final boolean addAll(int i6, Collection elements) {
        kotlin.jvm.internal.o.h(elements, "elements");
        C3236b c3236b = AbstractC3239e.Companion;
        int size = size();
        c3236b.getClass();
        C3236b.c(i6, size);
        if (elements.isEmpty()) {
            return false;
        }
        if (i6 == size()) {
            return addAll(elements);
        }
        p();
        h(elements.size() + size());
        int iO = o(size() + this.f26061a);
        int iO2 = o(this.f26061a + i6);
        int size2 = elements.size();
        if (i6 < ((size() + 1) >> 1)) {
            int i7 = this.f26061a;
            int length = i7 - size2;
            if (iO2 < i7) {
                Object[] objArr = this.f26062b;
                AbstractC3250p.B(objArr, length, objArr, i7, objArr.length);
                if (size2 >= iO2) {
                    Object[] objArr2 = this.f26062b;
                    AbstractC3250p.B(objArr2, objArr2.length - size2, objArr2, 0, iO2);
                } else {
                    Object[] objArr3 = this.f26062b;
                    AbstractC3250p.B(objArr3, objArr3.length - size2, objArr3, 0, size2);
                    Object[] objArr4 = this.f26062b;
                    AbstractC3250p.B(objArr4, 0, objArr4, size2, iO2);
                }
            } else if (length >= 0) {
                Object[] objArr5 = this.f26062b;
                AbstractC3250p.B(objArr5, length, objArr5, i7, iO2);
            } else {
                Object[] objArr6 = this.f26062b;
                length += objArr6.length;
                int i8 = iO2 - i7;
                int length2 = objArr6.length - length;
                if (length2 >= i8) {
                    AbstractC3250p.B(objArr6, length, objArr6, i7, iO2);
                } else {
                    AbstractC3250p.B(objArr6, length, objArr6, i7, i7 + length2);
                    Object[] objArr7 = this.f26062b;
                    AbstractC3250p.B(objArr7, 0, objArr7, this.f26061a + length2, iO2);
                }
            }
            this.f26061a = length;
            g(m(iO2 - size2), elements);
            return true;
        }
        int i9 = iO2 + size2;
        if (iO2 < iO) {
            int i10 = size2 + iO;
            Object[] objArr8 = this.f26062b;
            if (i10 <= objArr8.length) {
                AbstractC3250p.B(objArr8, i9, objArr8, iO2, iO);
            } else if (i9 >= objArr8.length) {
                AbstractC3250p.B(objArr8, i9 - objArr8.length, objArr8, iO2, iO);
            } else {
                int length3 = iO - (i10 - objArr8.length);
                AbstractC3250p.B(objArr8, 0, objArr8, length3, iO);
                Object[] objArr9 = this.f26062b;
                AbstractC3250p.B(objArr9, i9, objArr9, iO2, length3);
            }
        } else {
            Object[] objArr10 = this.f26062b;
            AbstractC3250p.B(objArr10, size2, objArr10, 0, iO);
            Object[] objArr11 = this.f26062b;
            if (i9 >= objArr11.length) {
                AbstractC3250p.B(objArr11, i9 - objArr11.length, objArr11, iO2, objArr11.length);
            } else {
                AbstractC3250p.B(objArr11, 0, objArr11, objArr11.length - size2, objArr11.length);
                Object[] objArr12 = this.f26062b;
                AbstractC3250p.B(objArr12, i9, objArr12, iO2, objArr12.length - size2);
            }
        }
        g(iO2, elements);
        return true;
    }

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