package com.google.common.collect;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import java.io.InvalidObjectException;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.util.ArrayList;
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.RandomAccess;

/* JADX INFO: loaded from: classes2.dex */
@GwtCompatible(emulated = true, serializable = true)
@ElementTypesAreNonnullByDefault
public abstract class ImmutableList<E> extends ImmutableCollection<E> implements List<E>, RandomAccess {

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    public static final n0 f23599b = new n0(0, RegularImmutableList.f23615e);
    private static final long serialVersionUID = -889275714;

    @J2ktIncompatible
    public static class SerializedForm implements Serializable {
        private static final long serialVersionUID = 0;
        final Object[] elements;

        public SerializedForm(Object[] objArr) {
            this.elements = objArr;
        }

        public Object readResolve() {
            return ImmutableList.r(this.elements);
        }
    }

    public class SubList extends ImmutableList<E> {

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

        /* JADX INFO: renamed from: d, reason: collision with root package name */
        public final transient int f23601d;

        public SubList(int i10, int i11) {
            this.f23600c = i10;
            this.f23601d = i11;
        }

        @Override // com.google.common.collect.ImmutableCollection
        public final Object[] g() {
            return ImmutableList.this.g();
        }

        @Override // java.util.List
        public final Object get(int i10) {
            com.google.common.base.h.e(i10, this.f23601d);
            return ImmutableList.this.get(i10 + this.f23600c);
        }

        @Override // com.google.common.collect.ImmutableCollection
        public final int h() {
            return ImmutableList.this.i() + this.f23600c + this.f23601d;
        }

        @Override // com.google.common.collect.ImmutableCollection
        public final int i() {
            return ImmutableList.this.i() + this.f23600c;
        }

        @Override // com.google.common.collect.ImmutableList, com.google.common.collect.ImmutableCollection, java.util.AbstractCollection, java.util.Collection, java.lang.Iterable
        public final Iterator iterator() {
            return listIterator(0);
        }

        @Override // com.google.common.collect.ImmutableCollection
        public final boolean j() {
            return true;
        }

        @Override // com.google.common.collect.ImmutableList, java.util.List
        public final ListIterator listIterator() {
            return listIterator(0);
        }

        @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
        public final int size() {
            return this.f23601d;
        }

        @Override // com.google.common.collect.ImmutableList, com.google.common.collect.ImmutableCollection
        @J2ktIncompatible
        @GwtIncompatible
        public Object writeReplace() {
            return super.writeReplace();
        }

        @Override // com.google.common.collect.ImmutableList, java.util.List
        /* JADX INFO: renamed from: z, reason: merged with bridge method [inline-methods] */
        public final ImmutableList subList(int i10, int i11) {
            com.google.common.base.h.h(i10, i11, this.f23601d);
            ImmutableList immutableList = ImmutableList.this;
            int i12 = this.f23600c;
            return immutableList.subList(i10 + i12, i11 + i12);
        }

        @Override // com.google.common.collect.ImmutableList, java.util.List
        public final /* bridge */ /* synthetic */ ListIterator listIterator(int i10) {
            return listIterator(i10);
        }
    }

    public static ImmutableList l(int i10, Object[] objArr) {
        return i10 == 0 ? RegularImmutableList.f23615e : new RegularImmutableList(objArr, i10);
    }

    public static m0 m() {
        return new m0(4);
    }

    public static m0 o(int i10) {
        z0.d(i10, "expectedSize");
        return new m0(i10);
    }

    public static ImmutableList p(Collection collection) {
        if (!(collection instanceof ImmutableCollection)) {
            Object[] array = collection.toArray();
            z0.b(array.length, array);
            return l(array.length, array);
        }
        ImmutableList immutableListC = ((ImmutableCollection) collection).c();
        if (!immutableListC.j()) {
            return immutableListC;
        }
        Object[] array2 = immutableListC.toArray();
        return l(array2.length, array2);
    }

    public static ImmutableList q(List list) {
        list.getClass();
        if (list instanceof Collection) {
            return p(list);
        }
        Iterator it = list.iterator();
        if (!it.hasNext()) {
            return RegularImmutableList.f23615e;
        }
        Object next = it.next();
        if (!it.hasNext()) {
            return w(next);
        }
        m0 m0Var = new m0(4);
        m0Var.c(next);
        while (it.hasNext()) {
            m0Var.c(it.next());
        }
        return m0Var.i();
    }

    public static ImmutableList r(Object[] objArr) {
        if (objArr.length == 0) {
            return RegularImmutableList.f23615e;
        }
        Object[] objArr2 = (Object[]) objArr.clone();
        z0.b(objArr2.length, objArr2);
        return l(objArr2.length, objArr2);
    }

    @J2ktIncompatible
    private void readObject(ObjectInputStream objectInputStream) throws InvalidObjectException {
        throw new InvalidObjectException("Use SerializedForm");
    }

    public static ImmutableList t() {
        return RegularImmutableList.f23615e;
    }

    public static ImmutableList u(Serializable serializable, Object obj, Object obj2) {
        Object[] objArr = {serializable, obj, obj2};
        z0.b(3, objArr);
        return l(3, objArr);
    }

    public static ImmutableList v(Long l10, Long l11, Long l12, Long l13, Long l14) {
        Object[] objArr = {l10, l11, l12, l13, l14};
        z0.b(5, objArr);
        return l(5, objArr);
    }

    public static ImmutableList w(Object obj) {
        Object[] objArr = {obj};
        z0.b(1, objArr);
        return l(1, objArr);
    }

    public static ImmutableList x(Object obj, Object obj2) {
        Object[] objArr = {obj, obj2};
        z0.b(2, objArr);
        return l(2, objArr);
    }

    /* JADX WARN: Multi-variable type inference failed */
    public static ImmutableList y(Comparator comparator, Iterable iterable) {
        Collection collection;
        comparator.getClass();
        if (iterable instanceof Collection) {
            collection = (Collection) iterable;
        } else {
            Iterator it = iterable.iterator();
            ArrayList arrayList = new ArrayList();
            it.getClass();
            while (it.hasNext()) {
                arrayList.add(it.next());
            }
            collection = arrayList;
        }
        Object[] array = collection.toArray();
        z0.b(array.length, array);
        Arrays.sort(array, comparator);
        return l(array.length, array);
    }

    @Override // java.util.List
    public final void add(int i10, Object obj) {
        throw new UnsupportedOperationException();
    }

    @Override // java.util.List
    public final boolean addAll(int i10, Collection collection) {
        throw new UnsupportedOperationException();
    }

    @Override // com.google.common.collect.ImmutableCollection
    public final ImmutableList c() {
        return this;
    }

    @Override // com.google.common.collect.ImmutableCollection, java.util.AbstractCollection, java.util.Collection
    public boolean contains(Object obj) {
        return indexOf(obj) >= 0;
    }

    @Override // java.util.Collection, java.util.List
    public final boolean equals(Object obj) {
        if (obj == this) {
            return true;
        }
        if (obj instanceof List) {
            List list = (List) obj;
            int size = size();
            if (size == list.size()) {
                if (list instanceof RandomAccess) {
                    for (int i10 = 0; i10 < size; i10++) {
                        if (com.google.common.base.h.j(get(i10), list.get(i10))) {
                        }
                    }
                    return true;
                }
                Iterator<E> it = iterator();
                Iterator<E> it2 = list.iterator();
                while (it.hasNext()) {
                    if (it2.hasNext() && com.google.common.base.h.j(it.next(), it2.next())) {
                    }
                }
                return !it2.hasNext();
            }
        }
        return false;
    }

    @Override // com.google.common.collect.ImmutableCollection
    public int f(int i10, Object[] objArr) {
        int size = size();
        for (int i11 = 0; i11 < size; i11++) {
            objArr[i10 + i11] = get(i11);
        }
        return i10 + size;
    }

    @Override // java.util.Collection, java.util.List
    public final int hashCode() {
        int size = size();
        int i10 = 1;
        for (int i11 = 0; i11 < size; i11++) {
            i10 = ~(~(get(i11).hashCode() + (i10 * 31)));
        }
        return i10;
    }

    @Override // java.util.List
    public int indexOf(Object obj) {
        if (obj == null) {
            return -1;
        }
        int size = size();
        for (int i10 = 0; i10 < size; i10++) {
            if (obj.equals(get(i10))) {
                return i10;
            }
        }
        return -1;
    }

    @Override // com.google.common.collect.ImmutableCollection, java.util.AbstractCollection, java.util.Collection, java.lang.Iterable
    public Iterator iterator() {
        return listIterator(0);
    }

    @Override // com.google.common.collect.ImmutableCollection
    /* JADX INFO: renamed from: k */
    public final v1 iterator() {
        return listIterator(0);
    }

    @Override // java.util.List
    public int lastIndexOf(Object obj) {
        if (obj == null) {
            return -1;
        }
        for (int size = size() - 1; size >= 0; size--) {
            if (obj.equals(get(size))) {
                return size;
            }
        }
        return -1;
    }

    @Override // java.util.List
    public final Object remove(int i10) {
        throw new UnsupportedOperationException();
    }

    @Override // java.util.List
    /* JADX INFO: renamed from: s, reason: merged with bridge method [inline-methods] */
    public final n0 listIterator(int i10) {
        com.google.common.base.h.g(i10, size());
        return isEmpty() ? f23599b : new n0(i10, this);
    }

    @Override // java.util.List
    public final Object set(int i10, Object obj) {
        throw new UnsupportedOperationException();
    }

    @Override // com.google.common.collect.ImmutableCollection
    @J2ktIncompatible
    @GwtIncompatible
    public Object writeReplace() {
        return new SerializedForm(toArray());
    }

    @Override // java.util.List
    /* JADX INFO: renamed from: z */
    public ImmutableList subList(int i10, int i11) {
        com.google.common.base.h.h(i10, i11, size());
        int i12 = i11 - i10;
        return i12 == size() ? this : i12 == 0 ? RegularImmutableList.f23615e : new SubList(i10, i12);
    }

    @Override // java.util.List
    public ListIterator listIterator() {
        return listIterator(0);
    }
}