package e4;

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;
import java.util.Spliterator;
import java.util.function.Consumer;
import java.util.function.IntFunction;
import java.util.function.UnaryOperator;

/* loaded from: classes2.dex */
public abstract class o extends m implements List, RandomAccess {

    class a extends e4.a {
        a(int i10, int i11) {
            super(i10, i11);
        }

        @Override // e4.a
        protected Object a(int i10) {
            return o.this.get(i10);
        }
    }

    class b extends o {

        /* renamed from: b, reason: collision with root package name */
        final transient int f9313b;

        /* renamed from: c, reason: collision with root package name */
        final transient int f9314c;

        b(int i10, int i11) {
            this.f9313b = i10;
            this.f9314c = i11;
        }

        @Override // e4.m
        boolean c() {
            return true;
        }

        @Override // java.util.List
        public Object get(int i10) {
            d4.c.e(i10, this.f9314c);
            return o.this.get(i10 + this.f9313b);
        }

        @Override // e4.o, java.util.AbstractCollection, java.util.Collection, java.lang.Iterable, java.util.List
        public /* bridge */ /* synthetic */ Iterator iterator() {
            return super.iterator();
        }

        @Override // e4.o, java.util.List
        public /* bridge */ /* synthetic */ ListIterator listIterator() {
            return super.listIterator();
        }

        @Override // e4.o, java.util.List
        /* renamed from: m */
        public o subList(int i10, int i11) {
            d4.c.j(i10, i11, this.f9314c);
            o oVar = o.this;
            int i12 = this.f9313b;
            return oVar.subList(i10 + i12, i11 + i12);
        }

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

        @Override // e4.o, java.util.List
        public /* bridge */ /* synthetic */ ListIterator listIterator(int i10) {
            return super.listIterator(i10);
        }
    }

    o() {
    }

    static o d(Object[] objArr) {
        return e(objArr, objArr.length);
    }

    static o e(Object[] objArr, int i10) {
        if (i10 == 0) {
            return k();
        }
        if (i10 == 1) {
            return l(objArr[0]);
        }
        if (i10 < objArr.length) {
            objArr = Arrays.copyOf(objArr, i10);
        }
        return new u(objArr);
    }

    private static o f(Object... objArr) {
        return d(r.b(objArr));
    }

    public static o g(Collection collection) {
        if (!(collection instanceof m)) {
            return f(collection.toArray());
        }
        o a10 = ((m) collection).a();
        return a10.c() ? d(a10.toArray()) : a10;
    }

    public static o k() {
        return u.f9321c;
    }

    public static o l(Object obj) {
        return new w(obj);
    }

    @Override // e4.m
    public final o a() {
        return this;
    }

    @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 // e4.m
    int b(Object[] objArr, int i10) {
        int size = size();
        for (int i11 = 0; i11 < size; i11++) {
            objArr[i10 + i11] = get(i11);
        }
        return i10 + size;
    }

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

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

    @Override // java.lang.Iterable
    public void forEach(Consumer consumer) {
        d4.c.g(consumer);
        int size = size();
        for (int i10 = 0; i10 < size; i10++) {
            consumer.accept(get(i10));
        }
    }

    @Override // java.util.AbstractCollection, java.util.Collection, java.lang.Iterable, java.util.List
    /* renamed from: h */
    public x iterator() {
        return listIterator();
    }

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

    @Override // java.util.List
    /* renamed from: i, reason: merged with bridge method [inline-methods] */
    public y listIterator() {
        return listIterator(0);
    }

    @Override // java.util.List
    public int indexOf(Object obj) {
        if (obj == null) {
            return -1;
        }
        return q.b(this, obj);
    }

    @Override // java.util.List
    /* renamed from: j */
    public y listIterator(int i10) {
        return new a(size(), i10);
    }

    @Override // java.util.List
    public int lastIndexOf(Object obj) {
        if (obj == null) {
            return -1;
        }
        return q.d(this, obj);
    }

    @Override // java.util.List
    /* renamed from: m */
    public o subList(int i10, int i11) {
        d4.c.j(i10, i11, size());
        int i12 = i11 - i10;
        return i12 == size() ? this : i12 == 0 ? k() : i12 == 1 ? l(get(i10)) : n(i10, i11);
    }

    o n(int i10, int i11) {
        return new b(i10, i11 - i10);
    }

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

    @Override // java.util.List
    public final void replaceAll(UnaryOperator unaryOperator) {
        throw new UnsupportedOperationException();
    }

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

    @Override // java.util.List
    public final void sort(Comparator comparator) {
        throw new UnsupportedOperationException();
    }

    @Override // java.util.Collection, java.lang.Iterable, java.util.List
    public Spliterator spliterator() {
        return l.a(size(), 1296, new IntFunction() { // from class: e4.n
            @Override // java.util.function.IntFunction
            public final Object apply(int i10) {
                return o.this.get(i10);
            }
        });
    }
}