package j$.util.stream;

import j$.util.Objects;
import j$.util.Optional;
import j$.util.Spliterator;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.BinaryOperator;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.function.ToDoubleFunction;
import java.util.function.ToIntFunction;
import java.util.function.ToLongFunction;
import java.util.stream.Collector;

/* JADX INFO: compiled from: r8-map-id-da1bda724d8b26dc30f90d2ccf434f42461d6c82e7dbdeb074f412e5504de99c */
/* JADX INFO: loaded from: classes2.dex */
public abstract class d5 extends a implements Stream {
    @Override // j$.util.stream.a
    public final g2 F(a aVar, Spliterator spliterator, boolean z, IntFunction intFunction) {
        return v3.B(aVar, spliterator, z, intFunction);
    }

    @Override // j$.util.stream.a
    public final boolean H(Spliterator spliterator, l5 l5Var) {
        boolean zE;
        do {
            zE = l5Var.e();
            if (zE) {
                break;
            }
        } while (spliterator.tryAdvance(l5Var));
        return zE;
    }

    @Override // j$.util.stream.a
    public final z6 I() {
        return z6.REFERENCE;
    }

    @Override // j$.util.stream.a
    public final y1 J(long j, IntFunction intFunction) {
        return v3.z(j, intFunction);
    }

    @Override // j$.util.stream.a
    public final Spliterator Q(a aVar, Supplier supplier, boolean z) {
        return new c8(aVar, supplier, z);
    }

    @Override // j$.util.stream.Stream
    public final boolean allMatch(Predicate predicate) {
        return ((Boolean) D(v3.W(t1.ALL, predicate))).booleanValue();
    }

    @Override // j$.util.stream.Stream
    public final boolean anyMatch(Predicate predicate) {
        return ((Boolean) D(v3.W(t1.ANY, predicate))).booleanValue();
    }

    @Override // j$.util.stream.Stream
    public final Stream b(j$.util.p pVar) {
        Objects.requireNonNull(pVar);
        return new p(this, y6.p | y6.n | y6.t, pVar, 6);
    }

    @Override // j$.util.stream.Stream
    public final Object collect(Supplier supplier, BiConsumer biConsumer, BiConsumer biConsumer2) {
        Objects.requireNonNull(supplier);
        Objects.requireNonNull(biConsumer);
        Objects.requireNonNull(biConsumer2);
        return D(new a4(z6.REFERENCE, biConsumer2, biConsumer, supplier, 3));
    }

    @Override // j$.util.stream.Stream
    public final long count() {
        return ((Long) D(new c4(2))).longValue();
    }

    @Override // j$.util.stream.Stream
    public final Stream distinct() {
        return new m(this, y6.m | y6.t);
    }

    @Override // j$.util.stream.Stream
    public final Stream dropWhile(Predicate predicate) {
        int i = y8.a;
        Objects.requireNonNull(predicate);
        return new h8(this, y8.b, predicate, 1);
    }

    @Override // j$.util.stream.Stream
    public final Stream filter(Predicate predicate) {
        Objects.requireNonNull(predicate);
        return new p(this, y6.t, predicate, 4);
    }

    @Override // j$.util.stream.Stream
    public final Optional findAny() {
        return (Optional) D(i0.d);
    }

    @Override // j$.util.stream.Stream
    public final Optional findFirst() {
        return (Optional) D(i0.c);
    }

    public void forEach(Consumer consumer) {
        Objects.requireNonNull(consumer);
        D(new p0(consumer, false));
    }

    public void forEachOrdered(Consumer consumer) {
        Objects.requireNonNull(consumer);
        D(new p0(consumer, true));
    }

    /* JADX WARN: Removed duplicated region for block: B:107:0x0154  */
    @Override // j$.util.stream.Stream
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public final Object g(i iVar) {
        i iVar2;
        Object objD;
        if (this.a.k) {
            Set<Collector.Characteristics> setCharacteristics = iVar.a.characteristics();
            if (setCharacteristics != null && !setCharacteristics.isEmpty()) {
                HashSet hashSet = new HashSet();
                Collector.Characteristics next = setCharacteristics.iterator().next();
                if (next instanceof h) {
                    Iterator<Collector.Characteristics> it = setCharacteristics.iterator();
                    while (it.hasNext()) {
                        try {
                            h hVar = (h) it.next();
                            hashSet.add(hVar == null ? null : hVar == h.CONCURRENT ? Collector.Characteristics.CONCURRENT : hVar == h.UNORDERED ? Collector.Characteristics.UNORDERED : Collector.Characteristics.IDENTITY_FINISH);
                        } catch (ClassCastException e) {
                            j$.util.f.a(e, "java.util.stream.Collector.Characteristics");
                            throw null;
                        }
                    }
                } else {
                    if (!(next instanceof Collector.Characteristics)) {
                        j$.util.f.a(next.getClass(), "java.util.stream.Collector.Characteristics");
                        throw null;
                    }
                    Iterator<Collector.Characteristics> it2 = setCharacteristics.iterator();
                    while (it2.hasNext()) {
                        try {
                            Collector.Characteristics next2 = it2.next();
                            hashSet.add(next2 == null ? null : next2 == Collector.Characteristics.CONCURRENT ? h.CONCURRENT : next2 == Collector.Characteristics.UNORDERED ? h.UNORDERED : h.IDENTITY_FINISH);
                        } catch (ClassCastException e2) {
                            j$.util.f.a(e2, "java.util.stream.Collector.Characteristics");
                            throw null;
                        }
                    }
                }
                setCharacteristics = hashSet;
            }
            if (setCharacteristics.contains(h.CONCURRENT)) {
                if (y6.ORDERED.q(this.f)) {
                    Set<Collector.Characteristics> setCharacteristics2 = iVar.a.characteristics();
                    if (setCharacteristics2 != null && !setCharacteristics2.isEmpty()) {
                        HashSet hashSet2 = new HashSet();
                        Collector.Characteristics next3 = setCharacteristics2.iterator().next();
                        if (next3 instanceof h) {
                            Iterator<Collector.Characteristics> it3 = setCharacteristics2.iterator();
                            while (it3.hasNext()) {
                                try {
                                    h hVar2 = (h) it3.next();
                                    hashSet2.add(hVar2 == null ? null : hVar2 == h.CONCURRENT ? Collector.Characteristics.CONCURRENT : hVar2 == h.UNORDERED ? Collector.Characteristics.UNORDERED : Collector.Characteristics.IDENTITY_FINISH);
                                } catch (ClassCastException e3) {
                                    j$.util.f.a(e3, "java.util.stream.Collector.Characteristics");
                                    throw null;
                                }
                            }
                        } else {
                            if (!(next3 instanceof Collector.Characteristics)) {
                                j$.util.f.a(next3.getClass(), "java.util.stream.Collector.Characteristics");
                                throw null;
                            }
                            Iterator<Collector.Characteristics> it4 = setCharacteristics2.iterator();
                            while (it4.hasNext()) {
                                try {
                                    Collector.Characteristics next4 = it4.next();
                                    hashSet2.add(next4 == null ? null : next4 == Collector.Characteristics.CONCURRENT ? h.CONCURRENT : next4 == Collector.Characteristics.UNORDERED ? h.UNORDERED : h.IDENTITY_FINISH);
                                } catch (ClassCastException e4) {
                                    j$.util.f.a(e4, "java.util.stream.Collector.Characteristics");
                                    throw null;
                                }
                            }
                        }
                        setCharacteristics2 = hashSet2;
                    }
                    if (setCharacteristics2.contains(h.UNORDERED)) {
                    }
                }
                objD = iVar.a.supplier().get();
                forEach(new j$.util.concurrent.s(7, iVar.a.accumulator(), objD));
                iVar2 = iVar;
            }
        } else {
            iVar2 = iVar;
            objD = D(new h4(z6.REFERENCE, iVar.a.combiner(), iVar.a.accumulator(), ((i) Objects.requireNonNull(iVar)).a.supplier(), iVar2));
        }
        Set<Collector.Characteristics> setCharacteristics3 = iVar2.a.characteristics();
        if (setCharacteristics3 != null && !setCharacteristics3.isEmpty()) {
            HashSet hashSet3 = new HashSet();
            Collector.Characteristics next5 = setCharacteristics3.iterator().next();
            if (next5 instanceof h) {
                Iterator<Collector.Characteristics> it5 = setCharacteristics3.iterator();
                while (it5.hasNext()) {
                    try {
                        h hVar3 = (h) it5.next();
                        hashSet3.add(hVar3 == null ? null : hVar3 == h.CONCURRENT ? Collector.Characteristics.CONCURRENT : hVar3 == h.UNORDERED ? Collector.Characteristics.UNORDERED : Collector.Characteristics.IDENTITY_FINISH);
                    } catch (ClassCastException e5) {
                        j$.util.f.a(e5, "java.util.stream.Collector.Characteristics");
                        throw null;
                    }
                }
            } else {
                if (!(next5 instanceof Collector.Characteristics)) {
                    j$.util.f.a(next5.getClass(), "java.util.stream.Collector.Characteristics");
                    throw null;
                }
                Iterator<Collector.Characteristics> it6 = setCharacteristics3.iterator();
                while (it6.hasNext()) {
                    try {
                        Collector.Characteristics next6 = it6.next();
                        hashSet3.add(next6 == null ? null : next6 == Collector.Characteristics.CONCURRENT ? h.CONCURRENT : next6 == Collector.Characteristics.UNORDERED ? h.UNORDERED : h.IDENTITY_FINISH);
                    } catch (ClassCastException e6) {
                        j$.util.f.a(e6, "java.util.stream.Collector.Characteristics");
                        throw null;
                    }
                }
            }
            setCharacteristics3 = hashSet3;
        }
        return setCharacteristics3.contains(h.IDENTITY_FINISH) ? objD : iVar2.a.finisher().apply(objD);
    }

    @Override // j$.util.stream.g
    public final Iterator iterator() {
        Spliterator spliterator = spliterator();
        Objects.requireNonNull(spliterator);
        return new j$.util.e1(spliterator);
    }

    @Override // j$.util.stream.Stream
    public final Stream limit(long j) {
        if (j >= 0) {
            return v3.X(this, 0L, j);
        }
        j$.time.g.c(Long.toString(j));
        return null;
    }

    @Override // j$.util.stream.Stream
    public final m1 m(j$.util.p pVar) {
        Objects.requireNonNull(pVar);
        return new f1(this, y6.p | y6.n | y6.t, pVar, 2);
    }

    @Override // j$.util.stream.Stream
    public final Stream map(Function function) {
        Objects.requireNonNull(function);
        return new p(this, y6.p | y6.n, function, 5);
    }

    @Override // j$.util.stream.Stream
    public final d0 mapToDouble(ToDoubleFunction toDoubleFunction) {
        Objects.requireNonNull(toDoubleFunction);
        return new w(this, y6.p | y6.n, toDoubleFunction, 2);
    }

    @Override // j$.util.stream.Stream
    public final IntStream mapToInt(ToIntFunction toIntFunction) {
        Objects.requireNonNull(toIntFunction);
        return new u0(this, y6.p | y6.n, toIntFunction, 2);
    }

    @Override // j$.util.stream.Stream
    public final m1 mapToLong(ToLongFunction toLongFunction) {
        Objects.requireNonNull(toLongFunction);
        return new f1(this, y6.p | y6.n, toLongFunction, 3);
    }

    @Override // j$.util.stream.Stream
    public final Optional max(Comparator comparator) {
        Objects.requireNonNull(comparator);
        return reduce(new j$.util.function.a(comparator, 0));
    }

    @Override // j$.util.stream.Stream
    public final Optional min(Comparator comparator) {
        Objects.requireNonNull(comparator);
        return reduce(new j$.util.function.a(comparator, 1));
    }

    @Override // j$.util.stream.Stream
    public final boolean noneMatch(Predicate predicate) {
        return ((Boolean) D(v3.W(t1.NONE, predicate))).booleanValue();
    }

    @Override // j$.util.stream.Stream
    public final Stream peek(Consumer consumer) {
        Objects.requireNonNull(consumer);
        return new p(this, consumer);
    }

    @Override // j$.util.stream.Stream
    public final d0 q(j$.util.p pVar) {
        Objects.requireNonNull(pVar);
        return new w(this, y6.p | y6.n | y6.t, pVar, 3);
    }

    @Override // j$.util.stream.Stream
    public final Optional reduce(BinaryOperator binaryOperator) {
        Objects.requireNonNull(binaryOperator);
        return (Optional) D(new y3(z6.REFERENCE, binaryOperator, 2));
    }

    @Override // j$.util.stream.Stream
    public final Object reduce(Object obj, BiFunction biFunction, BinaryOperator binaryOperator) {
        Objects.requireNonNull(biFunction);
        Objects.requireNonNull(binaryOperator);
        return D(new a4(z6.REFERENCE, binaryOperator, biFunction, obj, 2));
    }

    @Override // j$.util.stream.Stream
    public final Object reduce(Object obj, BinaryOperator binaryOperator) {
        Objects.requireNonNull(binaryOperator);
        Objects.requireNonNull(binaryOperator);
        return D(new a4(z6.REFERENCE, binaryOperator, binaryOperator, obj, 2));
    }

    @Override // j$.util.stream.Stream
    public final IntStream s(j$.util.p pVar) {
        Objects.requireNonNull(pVar);
        return new u0(this, y6.p | y6.n | y6.t, pVar, 3);
    }

    @Override // j$.util.stream.Stream
    public final Stream skip(long j) {
        if (j >= 0) {
            return j == 0 ? this : v3.X(this, j, -1L);
        }
        j$.time.g.c(Long.toString(j));
        return null;
    }

    @Override // j$.util.stream.Stream
    public final Stream sorted() {
        return new g6(this);
    }

    @Override // j$.util.stream.Stream
    public final Stream sorted(Comparator comparator) {
        return new g6(this, comparator);
    }

    @Override // j$.util.stream.Stream
    public final Stream takeWhile(Predicate predicate) {
        int i = y8.a;
        Objects.requireNonNull(predicate);
        return new h8(this, y8.a, predicate, 0);
    }

    @Override // j$.util.stream.Stream
    public final Object[] toArray() {
        return toArray(new c1(12));
    }

    @Override // j$.util.stream.Stream
    public final Object[] toArray(IntFunction intFunction) {
        return v3.J(E(intFunction), intFunction).m(intFunction);
    }

    @Override // j$.util.stream.Stream
    public final List toList() {
        return Collections.unmodifiableList(new ArrayList(Arrays.asList(toArray())));
    }
}