package androidx.compose.runtime.collection;

import E3.v;
import J4.e;
import J4.f;
import K4.a;
import K4.c;
import P4.g;
import androidx.compose.runtime.internal.StabilityInferred;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.NoSuchElementException;
import java.util.RandomAccess;
import kotlin.jvm.internal.n;
import kotlin.jvm.internal.o;
import x4.AbstractC3250p;
import x4.AbstractC3252r;

/* JADX INFO: loaded from: classes.dex */
@StabilityInferred(parameters = 0)
public final class MutableVector<T> implements RandomAccess {
    public static final int $stable = 8;
    public T[] content;
    private List<T> list;
    private int size;

    public static final class MutableVectorList<T> implements List<T>, c {
        private final MutableVector<T> vector;

        public MutableVectorList(MutableVector<T> mutableVector) {
            this.vector = mutableVector;
        }

        @Override // java.util.List, java.util.Collection
        public boolean add(T t6) {
            return this.vector.add(t6);
        }

        @Override // java.util.List
        public boolean addAll(int i6, Collection<? extends T> collection) {
            return this.vector.addAll(i6, collection);
        }

        @Override // java.util.List, java.util.Collection
        public void clear() {
            this.vector.clear();
        }

        @Override // java.util.List, java.util.Collection
        public boolean contains(Object obj) {
            return this.vector.contains(obj);
        }

        @Override // java.util.List, java.util.Collection
        public boolean containsAll(Collection<?> collection) {
            return this.vector.containsAll(collection);
        }

        @Override // java.util.List
        public T get(int i6) {
            MutableVectorKt.checkIndex(this, i6);
            return this.vector.content[i6];
        }

        public int getSize() {
            return this.vector.getSize();
        }

        @Override // java.util.List
        public int indexOf(Object obj) {
            return this.vector.indexOf(obj);
        }

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

        @Override // java.util.List, java.util.Collection, java.lang.Iterable
        public Iterator<T> iterator() {
            return new VectorListIterator(this, 0);
        }

        @Override // java.util.List
        public int lastIndexOf(Object obj) {
            return this.vector.lastIndexOf(obj);
        }

        @Override // java.util.List
        public ListIterator<T> listIterator() {
            return new VectorListIterator(this, 0);
        }

        @Override // java.util.List
        public final /* bridge */ T remove(int i6) {
            return removeAt(i6);
        }

        @Override // java.util.List, java.util.Collection
        public boolean removeAll(Collection<?> collection) {
            return this.vector.removeAll(collection);
        }

        public T removeAt(int i6) {
            MutableVectorKt.checkIndex(this, i6);
            return this.vector.removeAt(i6);
        }

        @Override // java.util.List, java.util.Collection
        public boolean retainAll(Collection<?> collection) {
            return this.vector.retainAll(collection);
        }

        @Override // java.util.List
        public T set(int i6, T t6) {
            MutableVectorKt.checkIndex(this, i6);
            return this.vector.set(i6, t6);
        }

        @Override // java.util.List, java.util.Collection
        public final /* bridge */ int size() {
            return getSize();
        }

        @Override // java.util.List
        public List<T> subList(int i6, int i7) {
            MutableVectorKt.checkSubIndex(this, i6, i7);
            return new SubList(this, i6, i7);
        }

        @Override // java.util.List, java.util.Collection
        public Object[] toArray() {
            return n.a(this);
        }

        @Override // java.util.List
        public void add(int i6, T t6) {
            this.vector.add(i6, t6);
        }

        @Override // java.util.List, java.util.Collection
        public boolean addAll(Collection<? extends T> collection) {
            return this.vector.addAll(collection);
        }

        @Override // java.util.List
        public ListIterator<T> listIterator(int i6) {
            return new VectorListIterator(this, i6);
        }

        @Override // java.util.List, java.util.Collection
        public boolean remove(Object obj) {
            return this.vector.remove(obj);
        }

        @Override // java.util.List, java.util.Collection
        public <T> T[] toArray(T[] tArr) {
            return (T[]) n.b(this, tArr);
        }
    }

    public static final class SubList<T> implements List<T>, c {
        private int end;
        private final List<T> list;
        private final int start;

        public SubList(List<T> list, int i6, int i7) {
            this.list = list;
            this.start = i6;
            this.end = i7;
        }

        @Override // java.util.List, java.util.Collection
        public boolean add(T t6) {
            List<T> list = this.list;
            int i6 = this.end;
            this.end = i6 + 1;
            list.add(i6, t6);
            return true;
        }

        @Override // java.util.List
        public boolean addAll(int i6, Collection<? extends T> collection) {
            this.list.addAll(i6 + this.start, collection);
            int size = collection.size();
            this.end += size;
            return size > 0;
        }

        @Override // java.util.List, java.util.Collection
        public void clear() {
            int i6 = this.end - 1;
            int i7 = this.start;
            if (i7 <= i6) {
                while (true) {
                    this.list.remove(i6);
                    if (i6 == i7) {
                        break;
                    } else {
                        i6--;
                    }
                }
            }
            this.end = this.start;
        }

        @Override // java.util.List, java.util.Collection
        public boolean contains(Object obj) {
            int i6 = this.end;
            for (int i7 = this.start; i7 < i6; i7++) {
                if (o.c(this.list.get(i7), obj)) {
                    return true;
                }
            }
            return false;
        }

        @Override // java.util.List, java.util.Collection
        public boolean containsAll(Collection<?> collection) {
            Iterator<T> it = collection.iterator();
            while (it.hasNext()) {
                if (!contains(it.next())) {
                    return false;
                }
            }
            return true;
        }

        @Override // java.util.List
        public T get(int i6) {
            MutableVectorKt.checkIndex(this, i6);
            return this.list.get(i6 + this.start);
        }

        public int getSize() {
            return this.end - this.start;
        }

        @Override // java.util.List
        public int indexOf(Object obj) {
            int i6 = this.end;
            for (int i7 = this.start; i7 < i6; i7++) {
                if (o.c(this.list.get(i7), obj)) {
                    return i7 - this.start;
                }
            }
            return -1;
        }

        @Override // java.util.List, java.util.Collection
        public boolean isEmpty() {
            return this.end == this.start;
        }

        @Override // java.util.List, java.util.Collection, java.lang.Iterable
        public Iterator<T> iterator() {
            return new VectorListIterator(this, 0);
        }

        @Override // java.util.List
        public int lastIndexOf(Object obj) {
            int i6 = this.end - 1;
            int i7 = this.start;
            if (i7 > i6) {
                return -1;
            }
            while (!o.c(this.list.get(i6), obj)) {
                if (i6 == i7) {
                    return -1;
                }
                i6--;
            }
            return i6 - this.start;
        }

        @Override // java.util.List
        public ListIterator<T> listIterator() {
            return new VectorListIterator(this, 0);
        }

        @Override // java.util.List
        public final /* bridge */ T remove(int i6) {
            return removeAt(i6);
        }

        @Override // java.util.List, java.util.Collection
        public boolean removeAll(Collection<?> collection) {
            int i6 = this.end;
            Iterator<T> it = collection.iterator();
            while (it.hasNext()) {
                remove(it.next());
            }
            return i6 != this.end;
        }

        public T removeAt(int i6) {
            MutableVectorKt.checkIndex(this, i6);
            this.end--;
            return this.list.remove(i6 + this.start);
        }

        @Override // java.util.List, java.util.Collection
        public boolean retainAll(Collection<?> collection) {
            int i6 = this.end;
            int i7 = i6 - 1;
            int i8 = this.start;
            if (i8 <= i7) {
                while (true) {
                    if (!collection.contains(this.list.get(i7))) {
                        this.list.remove(i7);
                        this.end--;
                    }
                    if (i7 == i8) {
                        break;
                    }
                    i7--;
                }
            }
            return i6 != this.end;
        }

        @Override // java.util.List
        public T set(int i6, T t6) {
            MutableVectorKt.checkIndex(this, i6);
            return this.list.set(i6 + this.start, t6);
        }

        @Override // java.util.List, java.util.Collection
        public final /* bridge */ int size() {
            return getSize();
        }

        @Override // java.util.List
        public List<T> subList(int i6, int i7) {
            MutableVectorKt.checkSubIndex(this, i6, i7);
            return new SubList(this, i6, i7);
        }

        @Override // java.util.List, java.util.Collection
        public Object[] toArray() {
            return n.a(this);
        }

        @Override // java.util.List
        public void add(int i6, T t6) {
            this.list.add(i6 + this.start, t6);
            this.end++;
        }

        @Override // java.util.List
        public ListIterator<T> listIterator(int i6) {
            return new VectorListIterator(this, i6);
        }

        @Override // java.util.List, java.util.Collection
        public boolean remove(Object obj) {
            int i6 = this.end;
            for (int i7 = this.start; i7 < i6; i7++) {
                if (o.c(this.list.get(i7), obj)) {
                    this.list.remove(i7);
                    this.end--;
                    return true;
                }
            }
            return false;
        }

        @Override // java.util.List, java.util.Collection
        public <T> T[] toArray(T[] tArr) {
            return (T[]) n.b(this, tArr);
        }

        @Override // java.util.List, java.util.Collection
        public boolean addAll(Collection<? extends T> collection) {
            this.list.addAll(this.end, collection);
            int size = collection.size();
            this.end += size;
            return size > 0;
        }
    }

    public static final class VectorListIterator<T> implements ListIterator<T>, a {
        private int index;
        private final List<T> list;

        public VectorListIterator(List<T> list, int i6) {
            this.list = list;
            this.index = i6;
        }

        @Override // java.util.ListIterator
        public void add(T t6) {
            this.list.add(this.index, t6);
            this.index++;
        }

        @Override // java.util.ListIterator, java.util.Iterator
        public boolean hasNext() {
            return this.index < this.list.size();
        }

        @Override // java.util.ListIterator
        public boolean hasPrevious() {
            return this.index > 0;
        }

        @Override // java.util.ListIterator, java.util.Iterator
        public T next() {
            List<T> list = this.list;
            int i6 = this.index;
            this.index = i6 + 1;
            return list.get(i6);
        }

        @Override // java.util.ListIterator
        public int nextIndex() {
            return this.index;
        }

        @Override // java.util.ListIterator
        public T previous() {
            int i6 = this.index - 1;
            this.index = i6;
            return this.list.get(i6);
        }

        @Override // java.util.ListIterator
        public int previousIndex() {
            return this.index - 1;
        }

        @Override // java.util.ListIterator, java.util.Iterator
        public void remove() {
            int i6 = this.index - 1;
            this.index = i6;
            this.list.remove(i6);
        }

        @Override // java.util.ListIterator
        public void set(T t6) {
            this.list.set(this.index, t6);
        }
    }

    public MutableVector(T[] tArr, int i6) {
        this.content = tArr;
        this.size = i6;
    }

    public static /* synthetic */ void getContent$annotations() {
    }

    public final boolean add(T t6) {
        int i6 = this.size + 1;
        if (this.content.length < i6) {
            resizeStorage(i6);
        }
        T[] tArr = this.content;
        int i7 = this.size;
        tArr[i7] = t6;
        this.size = i7 + 1;
        return true;
    }

    public final boolean addAll(int i6, List<? extends T> list) {
        if (list.isEmpty()) {
            return false;
        }
        int size = list.size();
        int i7 = this.size + size;
        if (this.content.length < i7) {
            resizeStorage(i7);
        }
        T[] tArr = this.content;
        int i8 = this.size;
        if (i6 != i8) {
            System.arraycopy(tArr, i6, tArr, i6 + size, i8 - i6);
        }
        int size2 = list.size();
        for (int i9 = 0; i9 < size2; i9++) {
            tArr[i6 + i9] = list.get(i9);
        }
        this.size += size;
        return true;
    }

    public final boolean any(J4.c cVar) {
        T[] tArr = this.content;
        int size = getSize();
        for (int i6 = 0; i6 < size; i6++) {
            if (((Boolean) cVar.invoke(tArr[i6])).booleanValue()) {
                return true;
            }
        }
        return false;
    }

    public final List<T> asMutableList() {
        List<T> list = this.list;
        if (list != null) {
            return list;
        }
        MutableVectorList mutableVectorList = new MutableVectorList(this);
        this.list = mutableVectorList;
        return mutableVectorList;
    }

    public final void clear() {
        T[] tArr = this.content;
        int i6 = this.size;
        for (int i7 = 0; i7 < i6; i7++) {
            tArr[i7] = null;
        }
        this.size = 0;
    }

    public final boolean contains(T t6) {
        int size = getSize() - 1;
        if (size >= 0) {
            for (int i6 = 0; !o.c(this.content[i6], t6); i6++) {
                if (i6 != size) {
                }
            }
            return true;
        }
        return false;
    }

    public final boolean containsAll(List<? extends T> list) {
        int size = list.size();
        for (int i6 = 0; i6 < size; i6++) {
            if (!contains(list.get(i6))) {
                return false;
            }
        }
        return true;
    }

    public final boolean contentEquals(MutableVector<T> mutableVector) {
        if (mutableVector.size != this.size) {
            return false;
        }
        int size = getSize() - 1;
        if (size >= 0) {
            for (int i6 = 0; o.c(mutableVector.content[i6], this.content[i6]); i6++) {
                if (i6 != size) {
                }
            }
            return false;
        }
        return true;
    }

    public final void ensureCapacity(int i6) {
        if (this.content.length < i6) {
            resizeStorage(i6);
        }
    }

    public final T first(J4.c cVar) {
        T[] tArr = this.content;
        int size = getSize();
        for (int i6 = 0; i6 < size; i6++) {
            T t6 = tArr[i6];
            if (((Boolean) cVar.invoke(t6)).booleanValue()) {
                return t6;
            }
        }
        throwNoSuchElementException("MutableVector contains no element matching the predicate.");
        throw new v();
    }

    public final T firstOrNull(J4.c cVar) {
        T[] tArr = this.content;
        int size = getSize();
        for (int i6 = 0; i6 < size; i6++) {
            T t6 = tArr[i6];
            if (((Boolean) cVar.invoke(t6)).booleanValue()) {
                return t6;
            }
        }
        return null;
    }

    public final <R> R fold(R r5, e eVar) {
        T[] tArr = this.content;
        int size = getSize();
        for (int i6 = 0; i6 < size; i6++) {
            r5 = (R) eVar.invoke(r5, tArr[i6]);
        }
        return r5;
    }

    public final <R> R foldIndexed(R r5, f fVar) {
        T[] tArr = this.content;
        int size = getSize();
        for (int i6 = 0; i6 < size; i6++) {
            r5 = (R) fVar.invoke(Integer.valueOf(i6), r5, tArr[i6]);
        }
        return r5;
    }

    public final <R> R foldRight(R r5, e eVar) {
        int size = getSize() - 1;
        T[] tArr = this.content;
        if (size >= tArr.length) {
            return r5;
        }
        while (size >= 0) {
            r5 = (R) eVar.invoke(tArr[size], r5);
            size--;
        }
        return r5;
    }

    public final <R> R foldRightIndexed(R r5, f fVar) {
        int size = getSize() - 1;
        T[] tArr = this.content;
        if (size >= tArr.length) {
            return r5;
        }
        while (size >= 0) {
            r5 = (R) fVar.invoke(Integer.valueOf(size), tArr[size], r5);
            size--;
        }
        return r5;
    }

    public final void forEach(J4.c cVar) {
        T[] tArr = this.content;
        int size = getSize();
        for (int i6 = 0; i6 < size; i6++) {
            cVar.invoke(tArr[i6]);
        }
    }

    public final void forEachIndexed(e eVar) {
        T[] tArr = this.content;
        int size = getSize();
        for (int i6 = 0; i6 < size; i6++) {
            eVar.invoke(Integer.valueOf(i6), tArr[i6]);
        }
    }

    public final void forEachReversed(J4.c cVar) {
        int size = getSize() - 1;
        T[] tArr = this.content;
        if (size >= tArr.length) {
            return;
        }
        while (size >= 0) {
            cVar.invoke(tArr[size]);
            size--;
        }
    }

    public final void forEachReversedIndexed(e eVar) {
        int size = getSize() - 1;
        T[] tArr = this.content;
        if (size >= tArr.length) {
            return;
        }
        while (size >= 0) {
            eVar.invoke(Integer.valueOf(size), tArr[size]);
            size--;
        }
    }

    public final T get(int i6) {
        return this.content[i6];
    }

    public final T[] getContent() {
        return this.content;
    }

    public final g getIndices() {
        return L4.a.l0(0, getSize());
    }

    public final int getLastIndex() {
        return getSize() - 1;
    }

    public final int getSize() {
        return this.size;
    }

    public final int indexOf(T t6) {
        T[] tArr = this.content;
        int i6 = this.size;
        for (int i7 = 0; i7 < i6; i7++) {
            if (o.c(t6, tArr[i7])) {
                return i7;
            }
        }
        return -1;
    }

    public final int indexOfFirst(J4.c cVar) {
        T[] tArr = this.content;
        int size = getSize();
        for (int i6 = 0; i6 < size; i6++) {
            if (((Boolean) cVar.invoke(tArr[i6])).booleanValue()) {
                return i6;
            }
        }
        return -1;
    }

    public final int indexOfLast(J4.c cVar) {
        int size = getSize() - 1;
        T[] tArr = this.content;
        if (size >= tArr.length) {
            return -1;
        }
        while (size >= 0) {
            if (((Boolean) cVar.invoke(tArr[size])).booleanValue()) {
                return size;
            }
            size--;
        }
        return -1;
    }

    public final boolean isEmpty() {
        return getSize() == 0;
    }

    public final boolean isNotEmpty() {
        return getSize() != 0;
    }

    public final T last(J4.c cVar) {
        T[] tArr = this.content;
        for (int size = getSize() - 1; size >= 0; size--) {
            T t6 = tArr[size];
            if (((Boolean) cVar.invoke(t6)).booleanValue()) {
                return t6;
            }
        }
        throwNoSuchElementException("MutableVector contains no element matching the predicate.");
        throw new v();
    }

    public final int lastIndexOf(T t6) {
        T[] tArr = this.content;
        for (int i6 = this.size - 1; i6 >= 0; i6--) {
            if (o.c(t6, tArr[i6])) {
                return i6;
            }
        }
        return -1;
    }

    public final T lastOrNull(J4.c cVar) {
        T[] tArr = this.content;
        for (int size = getSize() - 1; size >= 0; size--) {
            T t6 = tArr[size];
            if (((Boolean) cVar.invoke(t6)).booleanValue()) {
                return t6;
            }
        }
        return null;
    }

    public final <R> R[] map(J4.c cVar) {
        getSize();
        o.m();
        throw null;
    }

    public final <R> R[] mapIndexed(e eVar) {
        getSize();
        o.m();
        throw null;
    }

    public final <R> MutableVector<R> mapIndexedNotNull(e eVar) {
        getSize();
        o.m();
        throw null;
    }

    public final <R> MutableVector<R> mapNotNull(J4.c cVar) {
        getSize();
        o.m();
        throw null;
    }

    public final void minusAssign(T t6) {
        remove(t6);
    }

    public final void plusAssign(T t6) {
        add(t6);
    }

    public final boolean remove(T t6) {
        int iIndexOf = indexOf(t6);
        if (iIndexOf < 0) {
            return false;
        }
        removeAt(iIndexOf);
        return true;
    }

    public final boolean removeAll(List<? extends T> list) {
        int i6 = this.size;
        int size = list.size();
        for (int i7 = 0; i7 < size; i7++) {
            remove(list.get(i7));
        }
        return i6 != this.size;
    }

    public final T removeAt(int i6) {
        T[] tArr = this.content;
        T t6 = tArr[i6];
        if (i6 != getSize() - 1) {
            int i7 = i6 + 1;
            System.arraycopy(tArr, i7, tArr, i6, this.size - i7);
        }
        int i8 = this.size - 1;
        this.size = i8;
        tArr[i8] = null;
        return t6;
    }

    public final void removeIf(J4.c cVar) {
        int size = getSize();
        int i6 = 0;
        for (int i7 = 0; i7 < size; i7++) {
            if (((Boolean) cVar.invoke(this.content[i7])).booleanValue()) {
                i6++;
            } else if (i6 > 0) {
                T[] tArr = this.content;
                tArr[i7 - i6] = tArr[i7];
            }
        }
        int i8 = size - i6;
        AbstractC3250p.H(this.content, null, i8, size);
        setSize(i8);
    }

    public final void removeRange(int i6, int i7) {
        if (i7 > i6) {
            int i8 = this.size;
            if (i7 < i8) {
                T[] tArr = this.content;
                System.arraycopy(tArr, i7, tArr, i6, i8 - i7);
            }
            int i9 = this.size - (i7 - i6);
            int size = getSize() - 1;
            if (i9 <= size) {
                int i10 = i9;
                while (true) {
                    this.content[i10] = null;
                    if (i10 == size) {
                        break;
                    } else {
                        i10++;
                    }
                }
            }
            this.size = i9;
        }
    }

    public final void resizeStorage(int i6) {
        T[] tArr = this.content;
        int length = tArr.length;
        T[] tArr2 = (T[]) new Object[Math.max(i6, length * 2)];
        System.arraycopy(tArr, 0, tArr2, 0, length);
        this.content = tArr2;
    }

    public final boolean retainAll(Collection<? extends T> collection) {
        int i6 = this.size;
        for (int size = getSize() - 1; -1 < size; size--) {
            if (!collection.contains(this.content[size])) {
                removeAt(size);
            }
        }
        return i6 != this.size;
    }

    public final boolean reversedAny(J4.c cVar) {
        T[] tArr = this.content;
        for (int size = getSize() - 1; size >= 0; size--) {
            if (((Boolean) cVar.invoke(tArr[size])).booleanValue()) {
                return true;
            }
        }
        return false;
    }

    public final T set(int i6, T t6) {
        T[] tArr = this.content;
        T t7 = tArr[i6];
        tArr[i6] = t6;
        return t7;
    }

    public final void setSize(int i6) {
        this.size = i6;
    }

    public final void sortWith(Comparator<T> comparator) {
        T[] tArr = this.content;
        int i6 = this.size;
        o.h(tArr, "<this>");
        o.h(comparator, "comparator");
        Arrays.sort(tArr, 0, i6, comparator);
    }

    public final int sumBy(J4.c cVar) {
        T[] tArr = this.content;
        int iIntValue = 0;
        for (int i6 = 0; i6 < getSize(); i6++) {
            iIntValue += ((Number) cVar.invoke(tArr[i6])).intValue();
        }
        return iIntValue;
    }

    public final Void throwNoSuchElementException() {
        throwNoSuchElementException("MutableVector is empty.");
        throw new v();
    }

    public final boolean containsAll(Collection<? extends T> collection) {
        Iterator<T> it = collection.iterator();
        while (it.hasNext()) {
            if (!contains(it.next())) {
                return false;
            }
        }
        return true;
    }

    public final Void throwNoSuchElementException(String str) {
        throw new NoSuchElementException(str);
    }

    public final T firstOrNull() {
        if (getSize() == 0) {
            return null;
        }
        return this.content[0];
    }

    public final T lastOrNull() {
        if (getSize() == 0) {
            return null;
        }
        return this.content[getSize() - 1];
    }

    public final boolean removeAll(MutableVector<T> mutableVector) {
        int i6 = this.size;
        int size = mutableVector.getSize() - 1;
        if (size >= 0) {
            int i7 = 0;
            while (true) {
                remove(mutableVector.content[i7]);
                if (i7 == size) {
                    break;
                }
                i7++;
            }
        }
        return i6 != this.size;
    }

    public final void add(int i6, T t6) {
        int i7 = this.size + 1;
        if (this.content.length < i7) {
            resizeStorage(i7);
        }
        T[] tArr = this.content;
        int i8 = this.size;
        if (i6 != i8) {
            System.arraycopy(tArr, i6, tArr, i6 + 1, i8 - i6);
        }
        tArr[i6] = t6;
        this.size++;
    }

    public final boolean containsAll(MutableVector<T> mutableVector) {
        g gVarL0 = L4.a.l0(0, mutableVector.getSize());
        int i6 = gVarL0.f5676a;
        int i7 = gVarL0.f5677b;
        if (i6 > i7) {
            return true;
        }
        while (contains(mutableVector.content[i6])) {
            if (i6 == i7) {
                return true;
            }
            i6++;
        }
        return false;
    }

    public final T first() {
        if (getSize() != 0) {
            return this.content[0];
        }
        throwNoSuchElementException("MutableVector is empty.");
        throw new v();
    }

    public final T last() {
        if (getSize() != 0) {
            return this.content[getSize() - 1];
        }
        throwNoSuchElementException("MutableVector is empty.");
        throw new v();
    }

    public final boolean removeAll(Collection<? extends T> collection) {
        if (collection.isEmpty()) {
            return false;
        }
        int i6 = this.size;
        Iterator<T> it = collection.iterator();
        while (it.hasNext()) {
            remove(it.next());
        }
        return i6 != this.size;
    }

    public final boolean addAll(int i6, MutableVector<T> mutableVector) {
        int i7 = mutableVector.size;
        if (i7 == 0) {
            return false;
        }
        int i8 = this.size + i7;
        if (this.content.length < i8) {
            resizeStorage(i8);
        }
        T[] tArr = this.content;
        int i9 = this.size;
        if (i6 != i9) {
            System.arraycopy(tArr, i6, tArr, i6 + i7, i9 - i6);
        }
        System.arraycopy(mutableVector.content, 0, tArr, i6, i7);
        this.size += i7;
        return true;
    }

    public final boolean addAll(List<? extends T> list) {
        return addAll(getSize(), (List) list);
    }

    public final boolean addAll(MutableVector<T> mutableVector) {
        return addAll(getSize(), mutableVector);
    }

    public final boolean addAll(T[] tArr) {
        int length = tArr.length;
        if (length == 0) {
            return false;
        }
        int i6 = this.size + length;
        if (this.content.length < i6) {
            resizeStorage(i6);
        }
        System.arraycopy(tArr, 0, this.content, this.size, length);
        this.size += length;
        return true;
    }

    public final boolean addAll(int i6, Collection<? extends T> collection) {
        int i7 = 0;
        if (collection.isEmpty()) {
            return false;
        }
        int size = collection.size();
        int i8 = this.size + size;
        if (this.content.length < i8) {
            resizeStorage(i8);
        }
        T[] tArr = this.content;
        int i9 = this.size;
        if (i6 != i9) {
            System.arraycopy(tArr, i6, tArr, i6 + size, i9 - i6);
        }
        for (T t6 : collection) {
            int i10 = i7 + 1;
            if (i7 >= 0) {
                tArr[i7 + i6] = t6;
                i7 = i10;
            } else {
                AbstractC3252r.F();
                throw null;
            }
        }
        this.size += size;
        return true;
    }

    public final boolean addAll(Collection<? extends T> collection) {
        return addAll(this.size, collection);
    }
}