Initial commit

sources/io/reactivex/internal/operators/flowable/AbstractFlowableWithUpstream.java

@@ -0,0 +1,15 @@
+package io.reactivex.internal.operators.flowable;
+
+import io.reactivex.Flowable;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.fuseable.HasUpstreamPublisher;
+
+/* loaded from: classes2.dex */
+abstract class AbstractFlowableWithUpstream<T, R> extends Flowable<R> implements HasUpstreamPublisher<T> {
+    protected final Flowable<T> b;
+
+    AbstractFlowableWithUpstream(Flowable<T> flowable) {
+        ObjectHelper.a(flowable, "source is null");
+        this.b = flowable;
+    }
+}

sources/io/reactivex/internal/operators/flowable/FlowableFromObservable.java

@@ -0,0 +1,61 @@
+package io.reactivex.internal.operators.flowable;
+
+import io.reactivex.Flowable;
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
+/* loaded from: classes2.dex */
+public final class FlowableFromObservable<T> extends Flowable<T> {
+    private final Observable<T> b;
+
+    static final class SubscriberObserver<T> implements Observer<T>, Subscription {
+        final Subscriber<? super T> a;
+        Disposable b;
+
+        SubscriberObserver(Subscriber<? super T> subscriber) {
+            this.a = subscriber;
+        }
+
+        @Override // org.reactivestreams.Subscription
+        public void cancel() {
+            this.b.dispose();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.a.onComplete();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            this.a.onError(th);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            this.a.onNext(t);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            this.b = disposable;
+            this.a.onSubscribe(this);
+        }
+
+        @Override // org.reactivestreams.Subscription
+        public void request(long j) {
+        }
+    }
+
+    public FlowableFromObservable(Observable<T> observable) {
+        this.b = observable;
+    }
+
+    @Override // io.reactivex.Flowable
+    protected void b(Subscriber<? super T> subscriber) {
+        this.b.subscribe(new SubscriberObserver(subscriber));
+    }
+}

sources/io/reactivex/internal/operators/flowable/FlowableGroupBy$GroupBySubscriber.java

@@ -0,0 +1,323 @@
+package io.reactivex.internal.operators.flowable;
+
+import io.reactivex.FlowableSubscriber;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.flowables.GroupedFlowable;
+import io.reactivex.functions.Function;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.queue.SpscLinkedArrayQueue;
+import io.reactivex.internal.subscriptions.BasicIntQueueSubscription;
+import io.reactivex.internal.subscriptions.SubscriptionHelper;
+import io.reactivex.internal.util.BackpressureHelper;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Queue;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
+/* loaded from: classes2.dex */
+public final class FlowableGroupBy$GroupBySubscriber<T, K, V> extends BasicIntQueueSubscription<GroupedFlowable<K, V>> implements FlowableSubscriber<T> {
+    static final Object NULL_KEY = new Object();
+    private static final long serialVersionUID = -3688291656102519502L;
+    final int bufferSize;
+    final boolean delayError;
+    boolean done;
+    final Subscriber<? super GroupedFlowable<K, V>> downstream;
+    Throwable error;
+    final Queue<FlowableGroupBy$GroupedUnicast<K, V>> evictedGroups;
+    volatile boolean finished;
+    final Map<Object, FlowableGroupBy$GroupedUnicast<K, V>> groups;
+    final Function<? super T, ? extends K> keySelector;
+    boolean outputFused;
+    final SpscLinkedArrayQueue<GroupedFlowable<K, V>> queue;
+    Subscription upstream;
+    final Function<? super T, ? extends V> valueSelector;
+    final AtomicBoolean cancelled = new AtomicBoolean();
+    final AtomicLong requested = new AtomicLong();
+    final AtomicInteger groupCount = new AtomicInteger(1);
+
+    public FlowableGroupBy$GroupBySubscriber(Subscriber<? super GroupedFlowable<K, V>> subscriber, Function<? super T, ? extends K> function, Function<? super T, ? extends V> function2, int i, boolean z, Map<Object, FlowableGroupBy$GroupedUnicast<K, V>> map, Queue<FlowableGroupBy$GroupedUnicast<K, V>> queue) {
+        this.downstream = subscriber;
+        this.keySelector = function;
+        this.valueSelector = function2;
+        this.bufferSize = i;
+        this.delayError = z;
+        this.groups = map;
+        this.evictedGroups = queue;
+        this.queue = new SpscLinkedArrayQueue<>(i);
+    }
+
+    private void completeEvictions() {
+        if (this.evictedGroups != null) {
+            int i = 0;
+            while (true) {
+                FlowableGroupBy$GroupedUnicast<K, V> poll = this.evictedGroups.poll();
+                if (poll == null) {
+                    break;
+                }
+                poll.e();
+                i++;
+            }
+            if (i != 0) {
+                this.groupCount.addAndGet(-i);
+            }
+        }
+    }
+
+    @Override // org.reactivestreams.Subscription
+    public void cancel() {
+        if (this.cancelled.compareAndSet(false, true)) {
+            completeEvictions();
+            if (this.groupCount.decrementAndGet() == 0) {
+                this.upstream.cancel();
+            }
+        }
+    }
+
+    boolean checkTerminated(boolean z, boolean z2, Subscriber<?> subscriber, SpscLinkedArrayQueue<?> spscLinkedArrayQueue) {
+        if (this.cancelled.get()) {
+            spscLinkedArrayQueue.clear();
+            return true;
+        }
+        if (this.delayError) {
+            if (!z || !z2) {
+                return false;
+            }
+            Throwable th = this.error;
+            if (th != null) {
+                subscriber.onError(th);
+            } else {
+                subscriber.onComplete();
+            }
+            return true;
+        }
+        if (!z) {
+            return false;
+        }
+        Throwable th2 = this.error;
+        if (th2 != null) {
+            spscLinkedArrayQueue.clear();
+            subscriber.onError(th2);
+            return true;
+        }
+        if (!z2) {
+            return false;
+        }
+        subscriber.onComplete();
+        return true;
+    }
+
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public void clear() {
+        this.queue.clear();
+    }
+
+    void drain() {
+        if (getAndIncrement() != 0) {
+            return;
+        }
+        if (this.outputFused) {
+            drainFused();
+        } else {
+            drainNormal();
+        }
+    }
+
+    void drainFused() {
+        Throwable th;
+        SpscLinkedArrayQueue<GroupedFlowable<K, V>> spscLinkedArrayQueue = this.queue;
+        Subscriber<? super GroupedFlowable<K, V>> subscriber = this.downstream;
+        int i = 1;
+        while (!this.cancelled.get()) {
+            boolean z = this.finished;
+            if (z && !this.delayError && (th = this.error) != null) {
+                spscLinkedArrayQueue.clear();
+                subscriber.onError(th);
+                return;
+            }
+            subscriber.onNext(null);
+            if (z) {
+                Throwable th2 = this.error;
+                if (th2 != null) {
+                    subscriber.onError(th2);
+                    return;
+                } else {
+                    subscriber.onComplete();
+                    return;
+                }
+            }
+            i = addAndGet(-i);
+            if (i == 0) {
+                return;
+            }
+        }
+        spscLinkedArrayQueue.clear();
+    }
+
+    void drainNormal() {
+        SpscLinkedArrayQueue<GroupedFlowable<K, V>> spscLinkedArrayQueue = this.queue;
+        Subscriber<? super GroupedFlowable<K, V>> subscriber = this.downstream;
+        int i = 1;
+        do {
+            long j = this.requested.get();
+            long j2 = 0;
+            while (j2 != j) {
+                boolean z = this.finished;
+                GroupedFlowable<K, V> poll = spscLinkedArrayQueue.poll();
+                boolean z2 = poll == null;
+                if (checkTerminated(z, z2, subscriber, spscLinkedArrayQueue)) {
+                    return;
+                }
+                if (z2) {
+                    break;
+                }
+                subscriber.onNext(poll);
+                j2++;
+            }
+            if (j2 == j && checkTerminated(this.finished, spscLinkedArrayQueue.isEmpty(), subscriber, spscLinkedArrayQueue)) {
+                return;
+            }
+            if (j2 != 0) {
+                if (j != Long.MAX_VALUE) {
+                    this.requested.addAndGet(-j2);
+                }
+                this.upstream.request(j2);
+            }
+            i = addAndGet(-i);
+        } while (i != 0);
+    }
+
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public boolean isEmpty() {
+        return this.queue.isEmpty();
+    }
+
+    @Override // org.reactivestreams.Subscriber
+    public void onComplete() {
+        if (this.done) {
+            return;
+        }
+        Iterator<FlowableGroupBy$GroupedUnicast<K, V>> it = this.groups.values().iterator();
+        while (it.hasNext()) {
+            it.next().e();
+        }
+        this.groups.clear();
+        Queue<FlowableGroupBy$GroupedUnicast<K, V>> queue = this.evictedGroups;
+        if (queue != null) {
+            queue.clear();
+        }
+        this.done = true;
+        this.finished = true;
+        drain();
+    }
+
+    @Override // org.reactivestreams.Subscriber
+    public void onError(Throwable th) {
+        if (this.done) {
+            RxJavaPlugins.b(th);
+            return;
+        }
+        this.done = true;
+        Iterator<FlowableGroupBy$GroupedUnicast<K, V>> it = this.groups.values().iterator();
+        while (it.hasNext()) {
+            it.next().a(th);
+        }
+        this.groups.clear();
+        Queue<FlowableGroupBy$GroupedUnicast<K, V>> queue = this.evictedGroups;
+        if (queue != null) {
+            queue.clear();
+        }
+        this.error = th;
+        this.finished = true;
+        drain();
+    }
+
+    @Override // org.reactivestreams.Subscriber
+    public void onNext(T t) {
+        if (this.done) {
+            return;
+        }
+        SpscLinkedArrayQueue<GroupedFlowable<K, V>> spscLinkedArrayQueue = this.queue;
+        try {
+            K apply = this.keySelector.apply(t);
+            boolean z = false;
+            Object obj = apply != null ? apply : NULL_KEY;
+            FlowableGroupBy$GroupedUnicast<K, V> flowableGroupBy$GroupedUnicast = this.groups.get(obj);
+            if (flowableGroupBy$GroupedUnicast == null) {
+                if (this.cancelled.get()) {
+                    return;
+                }
+                flowableGroupBy$GroupedUnicast = FlowableGroupBy$GroupedUnicast.a(apply, this.bufferSize, this, this.delayError);
+                this.groups.put(obj, flowableGroupBy$GroupedUnicast);
+                this.groupCount.getAndIncrement();
+                z = true;
+            }
+            try {
+                V apply2 = this.valueSelector.apply(t);
+                ObjectHelper.a(apply2, "The valueSelector returned null");
+                flowableGroupBy$GroupedUnicast.a((FlowableGroupBy$GroupedUnicast<K, V>) apply2);
+                completeEvictions();
+                if (z) {
+                    spscLinkedArrayQueue.offer(flowableGroupBy$GroupedUnicast);
+                    drain();
+                }
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                this.upstream.cancel();
+                onError(th);
+            }
+        } catch (Throwable th2) {
+            Exceptions.b(th2);
+            this.upstream.cancel();
+            onError(th2);
+        }
+    }
+
+    @Override // org.reactivestreams.Subscriber
+    public void onSubscribe(Subscription subscription) {
+        if (SubscriptionHelper.validate(this.upstream, subscription)) {
+            this.upstream = subscription;
+            this.downstream.onSubscribe(this);
+            subscription.request(this.bufferSize);
+        }
+    }
+
+    @Override // org.reactivestreams.Subscription
+    public void request(long j) {
+        if (SubscriptionHelper.validate(j)) {
+            BackpressureHelper.a(this.requested, j);
+            drain();
+        }
+    }
+
+    @Override // io.reactivex.internal.fuseable.QueueFuseable
+    public int requestFusion(int i) {
+        if ((i & 2) == 0) {
+            return 0;
+        }
+        this.outputFused = true;
+        return 2;
+    }
+
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public GroupedFlowable<K, V> poll() {
+        return this.queue.poll();
+    }
+
+    public void cancel(K k) {
+        if (k == null) {
+            k = (K) NULL_KEY;
+        }
+        this.groups.remove(k);
+        if (this.groupCount.decrementAndGet() == 0) {
+            this.upstream.cancel();
+            if (getAndIncrement() == 0) {
+                this.queue.clear();
+            }
+        }
+    }
+}

sources/io/reactivex/internal/operators/flowable/FlowableGroupBy$GroupedUnicast.java

@@ -0,0 +1,35 @@
+package io.reactivex.internal.operators.flowable;
+
+import io.reactivex.flowables.GroupedFlowable;
+import org.reactivestreams.Subscriber;
+
+/* loaded from: classes2.dex */
+final class FlowableGroupBy$GroupedUnicast<K, T> extends GroupedFlowable<K, T> {
+    final FlowableGroupBy$State<T, K> b;
+
+    protected FlowableGroupBy$GroupedUnicast(K k, FlowableGroupBy$State<T, K> flowableGroupBy$State) {
+        super(k);
+        this.b = flowableGroupBy$State;
+    }
+
+    public static <T, K> FlowableGroupBy$GroupedUnicast<K, T> a(K k, int i, FlowableGroupBy$GroupBySubscriber<?, K, T> flowableGroupBy$GroupBySubscriber, boolean z) {
+        return new FlowableGroupBy$GroupedUnicast<>(k, new FlowableGroupBy$State(i, flowableGroupBy$GroupBySubscriber, k, z));
+    }
+
+    @Override // io.reactivex.Flowable
+    protected void b(Subscriber<? super T> subscriber) {
+        this.b.a(subscriber);
+    }
+
+    public void e() {
+        this.b.onComplete();
+    }
+
+    public void a(T t) {
+        this.b.onNext(t);
+    }
+
+    public void a(Throwable th) {
+        this.b.onError(th);
+    }
+}

sources/io/reactivex/internal/operators/flowable/FlowableGroupBy$State.java

@@ -0,0 +1,237 @@
+package io.reactivex.internal.operators.flowable;
+
+import io.reactivex.internal.queue.SpscLinkedArrayQueue;
+import io.reactivex.internal.subscriptions.BasicIntQueueSubscription;
+import io.reactivex.internal.subscriptions.EmptySubscription;
+import io.reactivex.internal.subscriptions.SubscriptionHelper;
+import io.reactivex.internal.util.BackpressureHelper;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.atomic.AtomicReference;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+
+/* loaded from: classes2.dex */
+final class FlowableGroupBy$State<T, K> extends BasicIntQueueSubscription<T> implements Publisher<T> {
+    final K a;
+    final SpscLinkedArrayQueue<T> b;
+    final FlowableGroupBy$GroupBySubscriber<?, K, T> c;
+    final boolean d;
+    volatile boolean f;
+    Throwable g;
+    boolean k;
+    int l;
+    final AtomicLong e = new AtomicLong();
+    final AtomicBoolean h = new AtomicBoolean();
+    final AtomicReference<Subscriber<? super T>> i = new AtomicReference<>();
+    final AtomicBoolean j = new AtomicBoolean();
+
+    FlowableGroupBy$State(int i, FlowableGroupBy$GroupBySubscriber<?, K, T> flowableGroupBy$GroupBySubscriber, K k, boolean z) {
+        this.b = new SpscLinkedArrayQueue<>(i);
+        this.c = flowableGroupBy$GroupBySubscriber;
+        this.a = k;
+        this.d = z;
+    }
+
+    @Override // org.reactivestreams.Publisher
+    public void a(Subscriber<? super T> subscriber) {
+        if (!this.j.compareAndSet(false, true)) {
+            EmptySubscription.error(new IllegalStateException("Only one Subscriber allowed!"), subscriber);
+            return;
+        }
+        subscriber.onSubscribe(this);
+        this.i.lazySet(subscriber);
+        drain();
+    }
+
+    @Override // org.reactivestreams.Subscription
+    public void cancel() {
+        if (this.h.compareAndSet(false, true)) {
+            this.c.cancel(this.a);
+        }
+    }
+
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public void clear() {
+        this.b.clear();
+    }
+
+    void drain() {
+        if (getAndIncrement() != 0) {
+            return;
+        }
+        if (this.k) {
+            drainFused();
+        } else {
+            drainNormal();
+        }
+    }
+
+    void drainFused() {
+        Throwable th;
+        SpscLinkedArrayQueue<T> spscLinkedArrayQueue = this.b;
+        Subscriber<? super T> subscriber = this.i.get();
+        int i = 1;
+        while (true) {
+            if (subscriber != null) {
+                if (this.h.get()) {
+                    spscLinkedArrayQueue.clear();
+                    return;
+                }
+                boolean z = this.f;
+                if (z && !this.d && (th = this.g) != null) {
+                    spscLinkedArrayQueue.clear();
+                    subscriber.onError(th);
+                    return;
+                }
+                subscriber.onNext(null);
+                if (z) {
+                    Throwable th2 = this.g;
+                    if (th2 != null) {
+                        subscriber.onError(th2);
+                        return;
+                    } else {
+                        subscriber.onComplete();
+                        return;
+                    }
+                }
+            }
+            i = addAndGet(-i);
+            if (i == 0) {
+                return;
+            }
+            if (subscriber == null) {
+                subscriber = this.i.get();
+            }
+        }
+    }
+
+    void drainNormal() {
+        SpscLinkedArrayQueue<T> spscLinkedArrayQueue = this.b;
+        boolean z = this.d;
+        Subscriber<? super T> subscriber = this.i.get();
+        int i = 1;
+        while (true) {
+            if (subscriber != null) {
+                long j = this.e.get();
+                long j2 = 0;
+                while (j2 != j) {
+                    boolean z2 = this.f;
+                    T poll = spscLinkedArrayQueue.poll();
+                    boolean z3 = poll == null;
+                    if (a(z2, z3, subscriber, z)) {
+                        return;
+                    }
+                    if (z3) {
+                        break;
+                    }
+                    subscriber.onNext(poll);
+                    j2++;
+                }
+                if (j2 == j && a(this.f, spscLinkedArrayQueue.isEmpty(), subscriber, z)) {
+                    return;
+                }
+                if (j2 != 0) {
+                    if (j != Long.MAX_VALUE) {
+                        this.e.addAndGet(-j2);
+                    }
+                    this.c.upstream.request(j2);
+                }
+            }
+            i = addAndGet(-i);
+            if (i == 0) {
+                return;
+            }
+            if (subscriber == null) {
+                subscriber = this.i.get();
+            }
+        }
+    }
+
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public boolean isEmpty() {
+        return this.b.isEmpty();
+    }
+
+    public void onComplete() {
+        this.f = true;
+        drain();
+    }
+
+    public void onError(Throwable th) {
+        this.g = th;
+        this.f = true;
+        drain();
+    }
+
+    public void onNext(T t) {
+        this.b.offer(t);
+        drain();
+    }
+
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public T poll() {
+        T poll = this.b.poll();
+        if (poll != null) {
+            this.l++;
+            return poll;
+        }
+        int i = this.l;
+        if (i == 0) {
+            return null;
+        }
+        this.l = 0;
+        this.c.upstream.request(i);
+        return null;
+    }
+
+    @Override // org.reactivestreams.Subscription
+    public void request(long j) {
+        if (SubscriptionHelper.validate(j)) {
+            BackpressureHelper.a(this.e, j);
+            drain();
+        }
+    }
+
+    @Override // io.reactivex.internal.fuseable.QueueFuseable
+    public int requestFusion(int i) {
+        if ((i & 2) == 0) {
+            return 0;
+        }
+        this.k = true;
+        return 2;
+    }
+
+    boolean a(boolean z, boolean z2, Subscriber<? super T> subscriber, boolean z3) {
+        if (this.h.get()) {
+            this.b.clear();
+            return true;
+        }
+        if (!z) {
+            return false;
+        }
+        if (z3) {
+            if (!z2) {
+                return false;
+            }
+            Throwable th = this.g;
+            if (th != null) {
+                subscriber.onError(th);
+            } else {
+                subscriber.onComplete();
+            }
+            return true;
+        }
+        Throwable th2 = this.g;
+        if (th2 != null) {
+            this.b.clear();
+            subscriber.onError(th2);
+            return true;
+        }
+        if (!z2) {
+            return false;
+        }
+        subscriber.onComplete();
+        return true;
+    }
+}

sources/io/reactivex/internal/operators/flowable/FlowableInternalHelper$RequestMax.java

@@ -0,0 +1,14 @@
+package io.reactivex.internal.operators.flowable;
+
+import io.reactivex.functions.Consumer;
+import org.reactivestreams.Subscription;
+
+/* loaded from: classes2.dex */
+public enum FlowableInternalHelper$RequestMax implements Consumer<Subscription> {
+    INSTANCE;
+
+    @Override // io.reactivex.functions.Consumer
+    public void accept(Subscription subscription) throws Exception {
+        subscription.request(Long.MAX_VALUE);
+    }
+}

sources/io/reactivex/internal/operators/flowable/FlowableOnBackpressureBuffer.java

@@ -0,0 +1,222 @@
+package io.reactivex.internal.operators.flowable;
+
+import io.reactivex.Flowable;
+import io.reactivex.FlowableSubscriber;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.exceptions.MissingBackpressureException;
+import io.reactivex.functions.Action;
+import io.reactivex.internal.fuseable.SimplePlainQueue;
+import io.reactivex.internal.queue.SpscArrayQueue;
+import io.reactivex.internal.queue.SpscLinkedArrayQueue;
+import io.reactivex.internal.subscriptions.BasicIntQueueSubscription;
+import io.reactivex.internal.subscriptions.SubscriptionHelper;
+import io.reactivex.internal.util.BackpressureHelper;
+import java.util.concurrent.atomic.AtomicLong;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
+/* loaded from: classes2.dex */
+public final class FlowableOnBackpressureBuffer<T> extends AbstractFlowableWithUpstream<T, T> {
+    final int c;
+    final boolean d;
+    final boolean e;
+    final Action f;
+
+    static final class BackpressureBufferSubscriber<T> extends BasicIntQueueSubscription<T> implements FlowableSubscriber<T> {
+        final Subscriber<? super T> a;
+        final SimplePlainQueue<T> b;
+        final boolean c;
+        final Action d;
+        Subscription e;
+        volatile boolean f;
+        volatile boolean g;
+        Throwable h;
+        final AtomicLong i = new AtomicLong();
+        boolean j;
+
+        BackpressureBufferSubscriber(Subscriber<? super T> subscriber, int i, boolean z, boolean z2, Action action) {
+            this.a = subscriber;
+            this.d = action;
+            this.c = z2;
+            this.b = z ? new SpscLinkedArrayQueue<>(i) : new SpscArrayQueue<>(i);
+        }
+
+        boolean a(boolean z, boolean z2, Subscriber<? super T> subscriber) {
+            if (this.f) {
+                this.b.clear();
+                return true;
+            }
+            if (!z) {
+                return false;
+            }
+            if (this.c) {
+                if (!z2) {
+                    return false;
+                }
+                Throwable th = this.h;
+                if (th != null) {
+                    subscriber.onError(th);
+                } else {
+                    subscriber.onComplete();
+                }
+                return true;
+            }
+            Throwable th2 = this.h;
+            if (th2 != null) {
+                this.b.clear();
+                subscriber.onError(th2);
+                return true;
+            }
+            if (!z2) {
+                return false;
+            }
+            subscriber.onComplete();
+            return true;
+        }
+
+        @Override // org.reactivestreams.Subscription
+        public void cancel() {
+            if (this.f) {
+                return;
+            }
+            this.f = true;
+            this.e.cancel();
+            if (getAndIncrement() == 0) {
+                this.b.clear();
+            }
+        }
+
+        @Override // io.reactivex.internal.fuseable.SimpleQueue
+        public void clear() {
+            this.b.clear();
+        }
+
+        void drain() {
+            if (getAndIncrement() == 0) {
+                SimplePlainQueue<T> simplePlainQueue = this.b;
+                Subscriber<? super T> subscriber = this.a;
+                int i = 1;
+                while (!a(this.g, simplePlainQueue.isEmpty(), subscriber)) {
+                    long j = this.i.get();
+                    long j2 = 0;
+                    while (j2 != j) {
+                        boolean z = this.g;
+                        T poll = simplePlainQueue.poll();
+                        boolean z2 = poll == null;
+                        if (a(z, z2, subscriber)) {
+                            return;
+                        }
+                        if (z2) {
+                            break;
+                        }
+                        subscriber.onNext(poll);
+                        j2++;
+                    }
+                    if (j2 == j && a(this.g, simplePlainQueue.isEmpty(), subscriber)) {
+                        return;
+                    }
+                    if (j2 != 0 && j != Long.MAX_VALUE) {
+                        this.i.addAndGet(-j2);
+                    }
+                    i = addAndGet(-i);
+                    if (i == 0) {
+                        return;
+                    }
+                }
+            }
+        }
+
+        @Override // io.reactivex.internal.fuseable.SimpleQueue
+        public boolean isEmpty() {
+            return this.b.isEmpty();
+        }
+
+        @Override // org.reactivestreams.Subscriber
+        public void onComplete() {
+            this.g = true;
+            if (this.j) {
+                this.a.onComplete();
+            } else {
+                drain();
+            }
+        }
+
+        @Override // org.reactivestreams.Subscriber
+        public void onError(Throwable th) {
+            this.h = th;
+            this.g = true;
+            if (this.j) {
+                this.a.onError(th);
+            } else {
+                drain();
+            }
+        }
+
+        @Override // org.reactivestreams.Subscriber
+        public void onNext(T t) {
+            if (this.b.offer(t)) {
+                if (this.j) {
+                    this.a.onNext(null);
+                    return;
+                } else {
+                    drain();
+                    return;
+                }
+            }
+            this.e.cancel();
+            MissingBackpressureException missingBackpressureException = new MissingBackpressureException("Buffer is full");
+            try {
+                this.d.run();
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                missingBackpressureException.initCause(th);
+            }
+            onError(missingBackpressureException);
+        }
+
+        @Override // org.reactivestreams.Subscriber
+        public void onSubscribe(Subscription subscription) {
+            if (SubscriptionHelper.validate(this.e, subscription)) {
+                this.e = subscription;
+                this.a.onSubscribe(this);
+                subscription.request(Long.MAX_VALUE);
+            }
+        }
+
+        @Override // io.reactivex.internal.fuseable.SimpleQueue
+        public T poll() throws Exception {
+            return this.b.poll();
+        }
+
+        @Override // org.reactivestreams.Subscription
+        public void request(long j) {
+            if (this.j || !SubscriptionHelper.validate(j)) {
+                return;
+            }
+            BackpressureHelper.a(this.i, j);
+            drain();
+        }
+
+        @Override // io.reactivex.internal.fuseable.QueueFuseable
+        public int requestFusion(int i) {
+            if ((i & 2) == 0) {
+                return 0;
+            }
+            this.j = true;
+            return 2;
+        }
+    }
+
+    public FlowableOnBackpressureBuffer(Flowable<T> flowable, int i, boolean z, boolean z2, Action action) {
+        super(flowable);
+        this.c = i;
+        this.d = z;
+        this.e = z2;
+        this.f = action;
+    }
+
+    @Override // io.reactivex.Flowable
+    protected void b(Subscriber<? super T> subscriber) {
+        this.b.a((FlowableSubscriber) new BackpressureBufferSubscriber(subscriber, this.c, this.d, this.e, this.f));
+    }
+}

sources/io/reactivex/internal/operators/flowable/FlowableOnBackpressureDrop.java

@@ -0,0 +1,102 @@
+package io.reactivex.internal.operators.flowable;
+
+import io.reactivex.Flowable;
+import io.reactivex.FlowableSubscriber;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Consumer;
+import io.reactivex.internal.subscriptions.SubscriptionHelper;
+import io.reactivex.internal.util.BackpressureHelper;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.atomic.AtomicLong;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
+/* loaded from: classes2.dex */
+public final class FlowableOnBackpressureDrop<T> extends AbstractFlowableWithUpstream<T, T> implements Consumer<T> {
+    final Consumer<? super T> c;
+
+    static final class BackpressureDropSubscriber<T> extends AtomicLong implements FlowableSubscriber<T>, Subscription {
+        final Subscriber<? super T> a;
+        final Consumer<? super T> b;
+        Subscription c;
+        boolean d;
+
+        BackpressureDropSubscriber(Subscriber<? super T> subscriber, Consumer<? super T> consumer) {
+            this.a = subscriber;
+            this.b = consumer;
+        }
+
+        @Override // org.reactivestreams.Subscription
+        public void cancel() {
+            this.c.cancel();
+        }
+
+        @Override // org.reactivestreams.Subscriber
+        public void onComplete() {
+            if (this.d) {
+                return;
+            }
+            this.d = true;
+            this.a.onComplete();
+        }
+
+        @Override // org.reactivestreams.Subscriber
+        public void onError(Throwable th) {
+            if (this.d) {
+                RxJavaPlugins.b(th);
+            } else {
+                this.d = true;
+                this.a.onError(th);
+            }
+        }
+
+        @Override // org.reactivestreams.Subscriber
+        public void onNext(T t) {
+            if (this.d) {
+                return;
+            }
+            if (get() != 0) {
+                this.a.onNext(t);
+                BackpressureHelper.b(this, 1L);
+                return;
+            }
+            try {
+                this.b.accept(t);
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                cancel();
+                onError(th);
+            }
+        }
+
+        @Override // org.reactivestreams.Subscriber
+        public void onSubscribe(Subscription subscription) {
+            if (SubscriptionHelper.validate(this.c, subscription)) {
+                this.c = subscription;
+                this.a.onSubscribe(this);
+                subscription.request(Long.MAX_VALUE);
+            }
+        }
+
+        @Override // org.reactivestreams.Subscription
+        public void request(long j) {
+            if (SubscriptionHelper.validate(j)) {
+                BackpressureHelper.a(this, j);
+            }
+        }
+    }
+
+    public FlowableOnBackpressureDrop(Flowable<T> flowable) {
+        super(flowable);
+        this.c = this;
+    }
+
+    @Override // io.reactivex.functions.Consumer
+    public void accept(T t) {
+    }
+
+    @Override // io.reactivex.Flowable
+    protected void b(Subscriber<? super T> subscriber) {
+        this.b.a((FlowableSubscriber) new BackpressureDropSubscriber(subscriber, this.c));
+    }
+}

sources/io/reactivex/internal/operators/flowable/FlowableOnBackpressureError.java

@@ -0,0 +1,87 @@
+package io.reactivex.internal.operators.flowable;
+
+import io.reactivex.Flowable;
+import io.reactivex.FlowableSubscriber;
+import io.reactivex.exceptions.MissingBackpressureException;
+import io.reactivex.internal.subscriptions.SubscriptionHelper;
+import io.reactivex.internal.util.BackpressureHelper;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.atomic.AtomicLong;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
+/* loaded from: classes2.dex */
+public final class FlowableOnBackpressureError<T> extends AbstractFlowableWithUpstream<T, T> {
+
+    static final class BackpressureErrorSubscriber<T> extends AtomicLong implements FlowableSubscriber<T>, Subscription {
+        final Subscriber<? super T> a;
+        Subscription b;
+        boolean c;
+
+        BackpressureErrorSubscriber(Subscriber<? super T> subscriber) {
+            this.a = subscriber;
+        }
+
+        @Override // org.reactivestreams.Subscription
+        public void cancel() {
+            this.b.cancel();
+        }
+
+        @Override // org.reactivestreams.Subscriber
+        public void onComplete() {
+            if (this.c) {
+                return;
+            }
+            this.c = true;
+            this.a.onComplete();
+        }
+
+        @Override // org.reactivestreams.Subscriber
+        public void onError(Throwable th) {
+            if (this.c) {
+                RxJavaPlugins.b(th);
+            } else {
+                this.c = true;
+                this.a.onError(th);
+            }
+        }
+
+        @Override // org.reactivestreams.Subscriber
+        public void onNext(T t) {
+            if (this.c) {
+                return;
+            }
+            if (get() == 0) {
+                onError(new MissingBackpressureException("could not emit value due to lack of requests"));
+            } else {
+                this.a.onNext(t);
+                BackpressureHelper.b(this, 1L);
+            }
+        }
+
+        @Override // org.reactivestreams.Subscriber
+        public void onSubscribe(Subscription subscription) {
+            if (SubscriptionHelper.validate(this.b, subscription)) {
+                this.b = subscription;
+                this.a.onSubscribe(this);
+                subscription.request(Long.MAX_VALUE);
+            }
+        }
+
+        @Override // org.reactivestreams.Subscription
+        public void request(long j) {
+            if (SubscriptionHelper.validate(j)) {
+                BackpressureHelper.a(this, j);
+            }
+        }
+    }
+
+    public FlowableOnBackpressureError(Flowable<T> flowable) {
+        super(flowable);
+    }
+
+    @Override // io.reactivex.Flowable
+    protected void b(Subscriber<? super T> subscriber) {
+        this.b.a((FlowableSubscriber) new BackpressureErrorSubscriber(subscriber));
+    }
+}

sources/io/reactivex/internal/operators/flowable/FlowableOnBackpressureLatest.java

@@ -0,0 +1,144 @@
+package io.reactivex.internal.operators.flowable;
+
+import io.reactivex.Flowable;
+import io.reactivex.FlowableSubscriber;
+import io.reactivex.internal.subscriptions.SubscriptionHelper;
+import io.reactivex.internal.util.BackpressureHelper;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.atomic.AtomicReference;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
+/* loaded from: classes2.dex */
+public final class FlowableOnBackpressureLatest<T> extends AbstractFlowableWithUpstream<T, T> {
+    public FlowableOnBackpressureLatest(Flowable<T> flowable) {
+        super(flowable);
+    }
+
+    @Override // io.reactivex.Flowable
+    protected void b(Subscriber<? super T> subscriber) {
+        this.b.a((FlowableSubscriber) new BackpressureLatestSubscriber(subscriber));
+    }
+
+    static final class BackpressureLatestSubscriber<T> extends AtomicInteger implements FlowableSubscriber<T>, Subscription {
+        final Subscriber<? super T> a;
+        Subscription b;
+        volatile boolean c;
+        Throwable d;
+        volatile boolean e;
+        final AtomicLong f = new AtomicLong();
+        final AtomicReference<T> g = new AtomicReference<>();
+
+        BackpressureLatestSubscriber(Subscriber<? super T> subscriber) {
+            this.a = subscriber;
+        }
+
+        void a() {
+            if (getAndIncrement() != 0) {
+                return;
+            }
+            Subscriber<? super T> subscriber = this.a;
+            AtomicLong atomicLong = this.f;
+            AtomicReference<T> atomicReference = this.g;
+            int i = 1;
+            do {
+                long j = 0;
+                while (true) {
+                    if (j == atomicLong.get()) {
+                        break;
+                    }
+                    boolean z = this.c;
+                    T andSet = atomicReference.getAndSet(null);
+                    boolean z2 = andSet == null;
+                    if (a(z, z2, subscriber, atomicReference)) {
+                        return;
+                    }
+                    if (z2) {
+                        break;
+                    }
+                    subscriber.onNext(andSet);
+                    j++;
+                }
+                if (j == atomicLong.get()) {
+                    if (a(this.c, atomicReference.get() == null, subscriber, atomicReference)) {
+                        return;
+                    }
+                }
+                if (j != 0) {
+                    BackpressureHelper.b(atomicLong, j);
+                }
+                i = addAndGet(-i);
+            } while (i != 0);
+        }
+
+        @Override // org.reactivestreams.Subscription
+        public void cancel() {
+            if (this.e) {
+                return;
+            }
+            this.e = true;
+            this.b.cancel();
+            if (getAndIncrement() == 0) {
+                this.g.lazySet(null);
+            }
+        }
+
+        @Override // org.reactivestreams.Subscriber
+        public void onComplete() {
+            this.c = true;
+            a();
+        }
+
+        @Override // org.reactivestreams.Subscriber
+        public void onError(Throwable th) {
+            this.d = th;
+            this.c = true;
+            a();
+        }
+
+        @Override // org.reactivestreams.Subscriber
+        public void onNext(T t) {
+            this.g.lazySet(t);
+            a();
+        }
+
+        @Override // org.reactivestreams.Subscriber
+        public void onSubscribe(Subscription subscription) {
+            if (SubscriptionHelper.validate(this.b, subscription)) {
+                this.b = subscription;
+                this.a.onSubscribe(this);
+                subscription.request(Long.MAX_VALUE);
+            }
+        }
+
+        @Override // org.reactivestreams.Subscription
+        public void request(long j) {
+            if (SubscriptionHelper.validate(j)) {
+                BackpressureHelper.a(this.f, j);
+                a();
+            }
+        }
+
+        boolean a(boolean z, boolean z2, Subscriber<?> subscriber, AtomicReference<T> atomicReference) {
+            if (this.e) {
+                atomicReference.lazySet(null);
+                return true;
+            }
+            if (!z) {
+                return false;
+            }
+            Throwable th = this.d;
+            if (th != null) {
+                atomicReference.lazySet(null);
+                subscriber.onError(th);
+                return true;
+            }
+            if (!z2) {
+                return false;
+            }
+            subscriber.onComplete();
+            return true;
+        }
+    }
+}

sources/io/reactivex/internal/operators/maybe/MaybeCallbackObserver.java

@@ -0,0 +1,78 @@
+package io.reactivex.internal.operators.maybe;
+
+import io.reactivex.MaybeObserver;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.CompositeException;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Action;
+import io.reactivex.functions.Consumer;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.functions.Functions;
+import io.reactivex.observers.LambdaConsumerIntrospection;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class MaybeCallbackObserver<T> extends AtomicReference<Disposable> implements MaybeObserver<T>, Disposable, LambdaConsumerIntrospection {
+    private static final long serialVersionUID = -6076952298809384986L;
+    final Action onComplete;
+    final Consumer<? super Throwable> onError;
+    final Consumer<? super T> onSuccess;
+
+    public MaybeCallbackObserver(Consumer<? super T> consumer, Consumer<? super Throwable> consumer2, Action action) {
+        this.onSuccess = consumer;
+        this.onError = consumer2;
+        this.onComplete = action;
+    }
+
+    @Override // io.reactivex.disposables.Disposable
+    public void dispose() {
+        DisposableHelper.dispose(this);
+    }
+
+    public boolean hasCustomOnError() {
+        return this.onError != Functions.e;
+    }
+
+    public boolean isDisposed() {
+        return DisposableHelper.isDisposed(get());
+    }
+
+    @Override // io.reactivex.MaybeObserver
+    public void onComplete() {
+        lazySet(DisposableHelper.DISPOSED);
+        try {
+            this.onComplete.run();
+        } catch (Throwable th) {
+            Exceptions.b(th);
+            RxJavaPlugins.b(th);
+        }
+    }
+
+    @Override // io.reactivex.MaybeObserver
+    public void onError(Throwable th) {
+        lazySet(DisposableHelper.DISPOSED);
+        try {
+            this.onError.accept(th);
+        } catch (Throwable th2) {
+            Exceptions.b(th2);
+            RxJavaPlugins.b(new CompositeException(th, th2));
+        }
+    }
+
+    @Override // io.reactivex.MaybeObserver
+    public void onSubscribe(Disposable disposable) {
+        DisposableHelper.setOnce(this, disposable);
+    }
+
+    @Override // io.reactivex.MaybeObserver
+    public void onSuccess(T t) {
+        lazySet(DisposableHelper.DISPOSED);
+        try {
+            this.onSuccess.accept(t);
+        } catch (Throwable th) {
+            Exceptions.b(th);
+            RxJavaPlugins.b(th);
+        }
+    }
+}

sources/io/reactivex/internal/operators/maybe/MaybeToFlowable.java

@@ -0,0 +1,61 @@
+package io.reactivex.internal.operators.maybe;
+
+import io.reactivex.Flowable;
+import io.reactivex.MaybeObserver;
+import io.reactivex.MaybeSource;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.fuseable.HasUpstreamMaybeSource;
+import io.reactivex.internal.subscriptions.DeferredScalarSubscription;
+import org.reactivestreams.Subscriber;
+
+/* loaded from: classes2.dex */
+public final class MaybeToFlowable<T> extends Flowable<T> implements HasUpstreamMaybeSource<T> {
+    final MaybeSource<T> b;
+
+    static final class MaybeToFlowableSubscriber<T> extends DeferredScalarSubscription<T> implements MaybeObserver<T> {
+        Disposable a;
+
+        MaybeToFlowableSubscriber(Subscriber<? super T> subscriber) {
+            super(subscriber);
+        }
+
+        @Override // io.reactivex.internal.subscriptions.DeferredScalarSubscription, org.reactivestreams.Subscription
+        public void cancel() {
+            super.cancel();
+            this.a.dispose();
+        }
+
+        @Override // io.reactivex.MaybeObserver
+        public void onComplete() {
+            this.downstream.onComplete();
+        }
+
+        @Override // io.reactivex.MaybeObserver
+        public void onError(Throwable th) {
+            this.downstream.onError(th);
+        }
+
+        @Override // io.reactivex.MaybeObserver
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.a, disposable)) {
+                this.a = disposable;
+                this.downstream.onSubscribe(this);
+            }
+        }
+
+        @Override // io.reactivex.MaybeObserver
+        public void onSuccess(T t) {
+            complete(t);
+        }
+    }
+
+    public MaybeToFlowable(MaybeSource<T> maybeSource) {
+        this.b = maybeSource;
+    }
+
+    @Override // io.reactivex.Flowable
+    protected void b(Subscriber<? super T> subscriber) {
+        this.b.a(new MaybeToFlowableSubscriber(subscriber));
+    }
+}

sources/io/reactivex/internal/operators/maybe/MaybeToObservable.java

@@ -0,0 +1,54 @@
+package io.reactivex.internal.operators.maybe;
+
+import io.reactivex.MaybeObserver;
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.fuseable.HasUpstreamMaybeSource;
+import io.reactivex.internal.observers.DeferredScalarDisposable;
+
+/* loaded from: classes2.dex */
+public final class MaybeToObservable<T> extends Observable<T> implements HasUpstreamMaybeSource<T> {
+
+    static final class MaybeToObservableObserver<T> extends DeferredScalarDisposable<T> implements MaybeObserver<T> {
+        Disposable a;
+
+        MaybeToObservableObserver(Observer<? super T> observer) {
+            super(observer);
+        }
+
+        @Override // io.reactivex.internal.observers.DeferredScalarDisposable, io.reactivex.disposables.Disposable
+        public void dispose() {
+            super.dispose();
+            this.a.dispose();
+        }
+
+        @Override // io.reactivex.MaybeObserver
+        public void onComplete() {
+            complete();
+        }
+
+        @Override // io.reactivex.MaybeObserver
+        public void onError(Throwable th) {
+            error(th);
+        }
+
+        @Override // io.reactivex.MaybeObserver
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.a, disposable)) {
+                this.a = disposable;
+                this.downstream.onSubscribe(this);
+            }
+        }
+
+        @Override // io.reactivex.MaybeObserver
+        public void onSuccess(T t) {
+            complete(t);
+        }
+    }
+
+    public static <T> MaybeObserver<T> a(Observer<? super T> observer) {
+        return new MaybeToObservableObserver(observer);
+    }
+}

sources/io/reactivex/internal/operators/maybe/MaybeToPublisher.java

@@ -0,0 +1,19 @@
+package io.reactivex.internal.operators.maybe;
+
+import io.reactivex.MaybeSource;
+import io.reactivex.functions.Function;
+import org.reactivestreams.Publisher;
+
+/* loaded from: classes2.dex */
+public enum MaybeToPublisher implements Function<MaybeSource<Object>, Publisher<Object>> {
+    INSTANCE;
+
+    public static <T> Function<MaybeSource<T>, Publisher<T>> instance() {
+        return INSTANCE;
+    }
+
+    @Override // io.reactivex.functions.Function
+    public Publisher<Object> apply(MaybeSource<Object> maybeSource) throws Exception {
+        return new MaybeToFlowable(maybeSource);
+    }
+}

sources/io/reactivex/internal/operators/mixed/ObservableConcatMapCompletable.java

@@ -0,0 +1,248 @@
+package io.reactivex.internal.operators.mixed;
+
+import io.reactivex.Completable;
+import io.reactivex.CompletableObserver;
+import io.reactivex.CompletableSource;
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Function;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.fuseable.QueueDisposable;
+import io.reactivex.internal.fuseable.SimpleQueue;
+import io.reactivex.internal.queue.SpscLinkedArrayQueue;
+import io.reactivex.internal.util.AtomicThrowable;
+import io.reactivex.internal.util.ErrorMode;
+import io.reactivex.internal.util.ExceptionHelper;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableConcatMapCompletable<T> extends Completable {
+    final Observable<T> a;
+    final Function<? super T, ? extends CompletableSource> b;
+    final ErrorMode c;
+    final int d;
+
+    public ObservableConcatMapCompletable(Observable<T> observable, Function<? super T, ? extends CompletableSource> function, ErrorMode errorMode, int i) {
+        this.a = observable;
+        this.b = function;
+        this.c = errorMode;
+        this.d = i;
+    }
+
+    @Override // io.reactivex.Completable
+    protected void b(CompletableObserver completableObserver) {
+        if (ScalarXMapZHelper.a(this.a, this.b, completableObserver)) {
+            return;
+        }
+        this.a.subscribe(new ConcatMapCompletableObserver(completableObserver, this.b, this.c, this.d));
+    }
+
+    static final class ConcatMapCompletableObserver<T> extends AtomicInteger implements Observer<T>, Disposable {
+        final CompletableObserver a;
+        final Function<? super T, ? extends CompletableSource> b;
+        final ErrorMode c;
+        final AtomicThrowable d = new AtomicThrowable();
+        final ConcatMapInnerObserver e = new ConcatMapInnerObserver(this);
+        final int f;
+        SimpleQueue<T> g;
+        Disposable h;
+        volatile boolean i;
+        volatile boolean j;
+        volatile boolean k;
+
+        static final class ConcatMapInnerObserver extends AtomicReference<Disposable> implements CompletableObserver {
+            final ConcatMapCompletableObserver<?> a;
+
+            ConcatMapInnerObserver(ConcatMapCompletableObserver<?> concatMapCompletableObserver) {
+                this.a = concatMapCompletableObserver;
+            }
+
+            void a() {
+                DisposableHelper.dispose(this);
+            }
+
+            @Override // io.reactivex.CompletableObserver, io.reactivex.MaybeObserver
+            public void onComplete() {
+                this.a.b();
+            }
+
+            @Override // io.reactivex.CompletableObserver
+            public void onError(Throwable th) {
+                this.a.a(th);
+            }
+
+            @Override // io.reactivex.CompletableObserver
+            public void onSubscribe(Disposable disposable) {
+                DisposableHelper.replace(this, disposable);
+            }
+        }
+
+        ConcatMapCompletableObserver(CompletableObserver completableObserver, Function<? super T, ? extends CompletableSource> function, ErrorMode errorMode, int i) {
+            this.a = completableObserver;
+            this.b = function;
+            this.c = errorMode;
+            this.f = i;
+        }
+
+        void a(Throwable th) {
+            if (!this.d.addThrowable(th)) {
+                RxJavaPlugins.b(th);
+                return;
+            }
+            if (this.c != ErrorMode.IMMEDIATE) {
+                this.i = false;
+                a();
+                return;
+            }
+            this.k = true;
+            this.h.dispose();
+            Throwable terminate = this.d.terminate();
+            if (terminate != ExceptionHelper.a) {
+                this.a.onError(terminate);
+            }
+            if (getAndIncrement() == 0) {
+                this.g.clear();
+            }
+        }
+
+        void b() {
+            this.i = false;
+            a();
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.k = true;
+            this.h.dispose();
+            this.e.a();
+            if (getAndIncrement() == 0) {
+                this.g.clear();
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.j = true;
+            a();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (!this.d.addThrowable(th)) {
+                RxJavaPlugins.b(th);
+                return;
+            }
+            if (this.c != ErrorMode.IMMEDIATE) {
+                this.j = true;
+                a();
+                return;
+            }
+            this.k = true;
+            this.e.a();
+            Throwable terminate = this.d.terminate();
+            if (terminate != ExceptionHelper.a) {
+                this.a.onError(terminate);
+            }
+            if (getAndIncrement() == 0) {
+                this.g.clear();
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            if (t != null) {
+                this.g.offer(t);
+            }
+            a();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.h, disposable)) {
+                this.h = disposable;
+                if (disposable instanceof QueueDisposable) {
+                    QueueDisposable queueDisposable = (QueueDisposable) disposable;
+                    int requestFusion = queueDisposable.requestFusion(3);
+                    if (requestFusion == 1) {
+                        this.g = queueDisposable;
+                        this.j = true;
+                        this.a.onSubscribe(this);
+                        a();
+                        return;
+                    }
+                    if (requestFusion == 2) {
+                        this.g = queueDisposable;
+                        this.a.onSubscribe(this);
+                        return;
+                    }
+                }
+                this.g = new SpscLinkedArrayQueue(this.f);
+                this.a.onSubscribe(this);
+            }
+        }
+
+        void a() {
+            boolean z;
+            if (getAndIncrement() != 0) {
+                return;
+            }
+            AtomicThrowable atomicThrowable = this.d;
+            ErrorMode errorMode = this.c;
+            while (!this.k) {
+                if (!this.i) {
+                    if (errorMode == ErrorMode.BOUNDARY && atomicThrowable.get() != null) {
+                        this.k = true;
+                        this.g.clear();
+                        this.a.onError(atomicThrowable.terminate());
+                        return;
+                    }
+                    boolean z2 = this.j;
+                    CompletableSource completableSource = null;
+                    try {
+                        T poll = this.g.poll();
+                        if (poll != null) {
+                            CompletableSource apply = this.b.apply(poll);
+                            ObjectHelper.a(apply, "The mapper returned a null CompletableSource");
+                            completableSource = apply;
+                            z = false;
+                        } else {
+                            z = true;
+                        }
+                        if (z2 && z) {
+                            this.k = true;
+                            Throwable terminate = atomicThrowable.terminate();
+                            if (terminate != null) {
+                                this.a.onError(terminate);
+                                return;
+                            } else {
+                                this.a.onComplete();
+                                return;
+                            }
+                        }
+                        if (!z) {
+                            this.i = true;
+                            completableSource.a(this.e);
+                        }
+                    } catch (Throwable th) {
+                        Exceptions.b(th);
+                        this.k = true;
+                        this.g.clear();
+                        this.h.dispose();
+                        atomicThrowable.addThrowable(th);
+                        this.a.onError(atomicThrowable.terminate());
+                        return;
+                    }
+                }
+                if (decrementAndGet() == 0) {
+                    return;
+                }
+            }
+            this.g.clear();
+        }
+    }
+}

sources/io/reactivex/internal/operators/mixed/ObservableConcatMapMaybe.java

@@ -0,0 +1,225 @@
+package io.reactivex.internal.operators.mixed;
+
+import io.reactivex.MaybeObserver;
+import io.reactivex.MaybeSource;
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Function;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.fuseable.SimplePlainQueue;
+import io.reactivex.internal.queue.SpscLinkedArrayQueue;
+import io.reactivex.internal.util.AtomicThrowable;
+import io.reactivex.internal.util.ErrorMode;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableConcatMapMaybe<T, R> extends Observable<R> {
+    final Observable<T> a;
+    final Function<? super T, ? extends MaybeSource<? extends R>> b;
+    final ErrorMode c;
+    final int d;
+
+    public ObservableConcatMapMaybe(Observable<T> observable, Function<? super T, ? extends MaybeSource<? extends R>> function, ErrorMode errorMode, int i) {
+        this.a = observable;
+        this.b = function;
+        this.c = errorMode;
+        this.d = i;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super R> observer) {
+        if (ScalarXMapZHelper.a(this.a, this.b, observer)) {
+            return;
+        }
+        this.a.subscribe(new ConcatMapMaybeMainObserver(observer, this.b, this.d, this.c));
+    }
+
+    static final class ConcatMapMaybeMainObserver<T, R> extends AtomicInteger implements Observer<T>, Disposable {
+        final Observer<? super R> a;
+        final Function<? super T, ? extends MaybeSource<? extends R>> b;
+        final AtomicThrowable c = new AtomicThrowable();
+        final ConcatMapMaybeObserver<R> d = new ConcatMapMaybeObserver<>(this);
+        final SimplePlainQueue<T> e;
+        final ErrorMode f;
+        Disposable g;
+        volatile boolean h;
+        volatile boolean i;
+        R j;
+        volatile int k;
+
+        static final class ConcatMapMaybeObserver<R> extends AtomicReference<Disposable> implements MaybeObserver<R> {
+            final ConcatMapMaybeMainObserver<?, R> a;
+
+            ConcatMapMaybeObserver(ConcatMapMaybeMainObserver<?, R> concatMapMaybeMainObserver) {
+                this.a = concatMapMaybeMainObserver;
+            }
+
+            void a() {
+                DisposableHelper.dispose(this);
+            }
+
+            @Override // io.reactivex.MaybeObserver
+            public void onComplete() {
+                this.a.b();
+            }
+
+            @Override // io.reactivex.MaybeObserver
+            public void onError(Throwable th) {
+                this.a.a(th);
+            }
+
+            @Override // io.reactivex.MaybeObserver
+            public void onSubscribe(Disposable disposable) {
+                DisposableHelper.replace(this, disposable);
+            }
+
+            @Override // io.reactivex.MaybeObserver
+            public void onSuccess(R r) {
+                this.a.a((ConcatMapMaybeMainObserver<?, R>) r);
+            }
+        }
+
+        ConcatMapMaybeMainObserver(Observer<? super R> observer, Function<? super T, ? extends MaybeSource<? extends R>> function, int i, ErrorMode errorMode) {
+            this.a = observer;
+            this.b = function;
+            this.f = errorMode;
+            this.e = new SpscLinkedArrayQueue(i);
+        }
+
+        void a(R r) {
+            this.j = r;
+            this.k = 2;
+            a();
+        }
+
+        void b() {
+            this.k = 0;
+            a();
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.i = true;
+            this.g.dispose();
+            this.d.a();
+            if (getAndIncrement() == 0) {
+                this.e.clear();
+                this.j = null;
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.h = true;
+            a();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (!this.c.addThrowable(th)) {
+                RxJavaPlugins.b(th);
+                return;
+            }
+            if (this.f == ErrorMode.IMMEDIATE) {
+                this.d.a();
+            }
+            this.h = true;
+            a();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            this.e.offer(t);
+            a();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.g, disposable)) {
+                this.g = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+
+        void a(Throwable th) {
+            if (this.c.addThrowable(th)) {
+                if (this.f != ErrorMode.END) {
+                    this.g.dispose();
+                }
+                this.k = 0;
+                a();
+                return;
+            }
+            RxJavaPlugins.b(th);
+        }
+
+        void a() {
+            if (getAndIncrement() != 0) {
+                return;
+            }
+            Observer<? super R> observer = this.a;
+            ErrorMode errorMode = this.f;
+            SimplePlainQueue<T> simplePlainQueue = this.e;
+            AtomicThrowable atomicThrowable = this.c;
+            int i = 1;
+            while (true) {
+                if (this.i) {
+                    simplePlainQueue.clear();
+                    this.j = null;
+                } else {
+                    int i2 = this.k;
+                    if (atomicThrowable.get() == null || (errorMode != ErrorMode.IMMEDIATE && (errorMode != ErrorMode.BOUNDARY || i2 != 0))) {
+                        if (i2 == 0) {
+                            boolean z = this.h;
+                            T poll = simplePlainQueue.poll();
+                            boolean z2 = poll == null;
+                            if (z && z2) {
+                                Throwable terminate = atomicThrowable.terminate();
+                                if (terminate == null) {
+                                    observer.onComplete();
+                                    return;
+                                } else {
+                                    observer.onError(terminate);
+                                    return;
+                                }
+                            }
+                            if (!z2) {
+                                try {
+                                    MaybeSource<? extends R> apply = this.b.apply(poll);
+                                    ObjectHelper.a(apply, "The mapper returned a null MaybeSource");
+                                    MaybeSource<? extends R> maybeSource = apply;
+                                    this.k = 1;
+                                    maybeSource.a(this.d);
+                                } catch (Throwable th) {
+                                    Exceptions.b(th);
+                                    this.g.dispose();
+                                    simplePlainQueue.clear();
+                                    atomicThrowable.addThrowable(th);
+                                    observer.onError(atomicThrowable.terminate());
+                                    return;
+                                }
+                            }
+                        } else if (i2 == 2) {
+                            R r = this.j;
+                            this.j = null;
+                            observer.onNext(r);
+                            this.k = 0;
+                        }
+                    }
+                }
+                i = addAndGet(-i);
+                if (i == 0) {
+                    return;
+                }
+            }
+            simplePlainQueue.clear();
+            this.j = null;
+            observer.onError(atomicThrowable.terminate());
+        }
+    }
+}

sources/io/reactivex/internal/operators/mixed/ObservableConcatMapSingle.java

@@ -0,0 +1,215 @@
+package io.reactivex.internal.operators.mixed;
+
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.SingleObserver;
+import io.reactivex.SingleSource;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Function;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.fuseable.SimplePlainQueue;
+import io.reactivex.internal.queue.SpscLinkedArrayQueue;
+import io.reactivex.internal.util.AtomicThrowable;
+import io.reactivex.internal.util.ErrorMode;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableConcatMapSingle<T, R> extends Observable<R> {
+    final Observable<T> a;
+    final Function<? super T, ? extends SingleSource<? extends R>> b;
+    final ErrorMode c;
+    final int d;
+
+    public ObservableConcatMapSingle(Observable<T> observable, Function<? super T, ? extends SingleSource<? extends R>> function, ErrorMode errorMode, int i) {
+        this.a = observable;
+        this.b = function;
+        this.c = errorMode;
+        this.d = i;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super R> observer) {
+        if (ScalarXMapZHelper.b(this.a, this.b, observer)) {
+            return;
+        }
+        this.a.subscribe(new ConcatMapSingleMainObserver(observer, this.b, this.d, this.c));
+    }
+
+    static final class ConcatMapSingleMainObserver<T, R> extends AtomicInteger implements Observer<T>, Disposable {
+        final Observer<? super R> a;
+        final Function<? super T, ? extends SingleSource<? extends R>> b;
+        final AtomicThrowable c = new AtomicThrowable();
+        final ConcatMapSingleObserver<R> d = new ConcatMapSingleObserver<>(this);
+        final SimplePlainQueue<T> e;
+        final ErrorMode f;
+        Disposable g;
+        volatile boolean h;
+        volatile boolean i;
+        R j;
+        volatile int k;
+
+        static final class ConcatMapSingleObserver<R> extends AtomicReference<Disposable> implements SingleObserver<R> {
+            final ConcatMapSingleMainObserver<?, R> a;
+
+            ConcatMapSingleObserver(ConcatMapSingleMainObserver<?, R> concatMapSingleMainObserver) {
+                this.a = concatMapSingleMainObserver;
+            }
+
+            void a() {
+                DisposableHelper.dispose(this);
+            }
+
+            @Override // io.reactivex.SingleObserver
+            public void onError(Throwable th) {
+                this.a.a(th);
+            }
+
+            @Override // io.reactivex.SingleObserver
+            public void onSubscribe(Disposable disposable) {
+                DisposableHelper.replace(this, disposable);
+            }
+
+            @Override // io.reactivex.SingleObserver
+            public void onSuccess(R r) {
+                this.a.a((ConcatMapSingleMainObserver<?, R>) r);
+            }
+        }
+
+        ConcatMapSingleMainObserver(Observer<? super R> observer, Function<? super T, ? extends SingleSource<? extends R>> function, int i, ErrorMode errorMode) {
+            this.a = observer;
+            this.b = function;
+            this.f = errorMode;
+            this.e = new SpscLinkedArrayQueue(i);
+        }
+
+        void a(R r) {
+            this.j = r;
+            this.k = 2;
+            a();
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.i = true;
+            this.g.dispose();
+            this.d.a();
+            if (getAndIncrement() == 0) {
+                this.e.clear();
+                this.j = null;
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.h = true;
+            a();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (!this.c.addThrowable(th)) {
+                RxJavaPlugins.b(th);
+                return;
+            }
+            if (this.f == ErrorMode.IMMEDIATE) {
+                this.d.a();
+            }
+            this.h = true;
+            a();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            this.e.offer(t);
+            a();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.g, disposable)) {
+                this.g = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+
+        void a(Throwable th) {
+            if (this.c.addThrowable(th)) {
+                if (this.f != ErrorMode.END) {
+                    this.g.dispose();
+                }
+                this.k = 0;
+                a();
+                return;
+            }
+            RxJavaPlugins.b(th);
+        }
+
+        void a() {
+            if (getAndIncrement() != 0) {
+                return;
+            }
+            Observer<? super R> observer = this.a;
+            ErrorMode errorMode = this.f;
+            SimplePlainQueue<T> simplePlainQueue = this.e;
+            AtomicThrowable atomicThrowable = this.c;
+            int i = 1;
+            while (true) {
+                if (this.i) {
+                    simplePlainQueue.clear();
+                    this.j = null;
+                } else {
+                    int i2 = this.k;
+                    if (atomicThrowable.get() == null || (errorMode != ErrorMode.IMMEDIATE && (errorMode != ErrorMode.BOUNDARY || i2 != 0))) {
+                        if (i2 == 0) {
+                            boolean z = this.h;
+                            T poll = simplePlainQueue.poll();
+                            boolean z2 = poll == null;
+                            if (z && z2) {
+                                Throwable terminate = atomicThrowable.terminate();
+                                if (terminate == null) {
+                                    observer.onComplete();
+                                    return;
+                                } else {
+                                    observer.onError(terminate);
+                                    return;
+                                }
+                            }
+                            if (!z2) {
+                                try {
+                                    SingleSource<? extends R> apply = this.b.apply(poll);
+                                    ObjectHelper.a(apply, "The mapper returned a null SingleSource");
+                                    SingleSource<? extends R> singleSource = apply;
+                                    this.k = 1;
+                                    singleSource.a(this.d);
+                                } catch (Throwable th) {
+                                    Exceptions.b(th);
+                                    this.g.dispose();
+                                    simplePlainQueue.clear();
+                                    atomicThrowable.addThrowable(th);
+                                    observer.onError(atomicThrowable.terminate());
+                                    return;
+                                }
+                            }
+                        } else if (i2 == 2) {
+                            R r = this.j;
+                            this.j = null;
+                            observer.onNext(r);
+                            this.k = 0;
+                        }
+                    }
+                }
+                i = addAndGet(-i);
+                if (i == 0) {
+                    return;
+                }
+            }
+            simplePlainQueue.clear();
+            this.j = null;
+            observer.onError(atomicThrowable.terminate());
+        }
+    }
+}

sources/io/reactivex/internal/operators/mixed/ObservableSwitchMapCompletable.java

@@ -0,0 +1,189 @@
+package io.reactivex.internal.operators.mixed;
+
+import io.reactivex.Completable;
+import io.reactivex.CompletableObserver;
+import io.reactivex.CompletableSource;
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Function;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.util.AtomicThrowable;
+import io.reactivex.internal.util.ExceptionHelper;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableSwitchMapCompletable<T> extends Completable {
+    final Observable<T> a;
+    final Function<? super T, ? extends CompletableSource> b;
+    final boolean c;
+
+    public ObservableSwitchMapCompletable(Observable<T> observable, Function<? super T, ? extends CompletableSource> function, boolean z) {
+        this.a = observable;
+        this.b = function;
+        this.c = z;
+    }
+
+    @Override // io.reactivex.Completable
+    protected void b(CompletableObserver completableObserver) {
+        if (ScalarXMapZHelper.a(this.a, this.b, completableObserver)) {
+            return;
+        }
+        this.a.subscribe(new SwitchMapCompletableObserver(completableObserver, this.b, this.c));
+    }
+
+    static final class SwitchMapCompletableObserver<T> implements Observer<T>, Disposable {
+        static final SwitchMapInnerObserver h = new SwitchMapInnerObserver(null);
+        final CompletableObserver a;
+        final Function<? super T, ? extends CompletableSource> b;
+        final boolean c;
+        final AtomicThrowable d = new AtomicThrowable();
+        final AtomicReference<SwitchMapInnerObserver> e = new AtomicReference<>();
+        volatile boolean f;
+        Disposable g;
+
+        static final class SwitchMapInnerObserver extends AtomicReference<Disposable> implements CompletableObserver {
+            final SwitchMapCompletableObserver<?> a;
+
+            SwitchMapInnerObserver(SwitchMapCompletableObserver<?> switchMapCompletableObserver) {
+                this.a = switchMapCompletableObserver;
+            }
+
+            void a() {
+                DisposableHelper.dispose(this);
+            }
+
+            @Override // io.reactivex.CompletableObserver, io.reactivex.MaybeObserver
+            public void onComplete() {
+                this.a.a(this);
+            }
+
+            @Override // io.reactivex.CompletableObserver
+            public void onError(Throwable th) {
+                this.a.a(this, th);
+            }
+
+            @Override // io.reactivex.CompletableObserver
+            public void onSubscribe(Disposable disposable) {
+                DisposableHelper.setOnce(this, disposable);
+            }
+        }
+
+        SwitchMapCompletableObserver(CompletableObserver completableObserver, Function<? super T, ? extends CompletableSource> function, boolean z) {
+            this.a = completableObserver;
+            this.b = function;
+            this.c = z;
+        }
+
+        void a() {
+            SwitchMapInnerObserver andSet = this.e.getAndSet(h);
+            if (andSet == null || andSet == h) {
+                return;
+            }
+            andSet.a();
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.g.dispose();
+            a();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.f = true;
+            if (this.e.get() == null) {
+                Throwable terminate = this.d.terminate();
+                if (terminate == null) {
+                    this.a.onComplete();
+                } else {
+                    this.a.onError(terminate);
+                }
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (!this.d.addThrowable(th)) {
+                RxJavaPlugins.b(th);
+                return;
+            }
+            if (this.c) {
+                onComplete();
+                return;
+            }
+            a();
+            Throwable terminate = this.d.terminate();
+            if (terminate != ExceptionHelper.a) {
+                this.a.onError(terminate);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            SwitchMapInnerObserver switchMapInnerObserver;
+            try {
+                CompletableSource apply = this.b.apply(t);
+                ObjectHelper.a(apply, "The mapper returned a null CompletableSource");
+                CompletableSource completableSource = apply;
+                SwitchMapInnerObserver switchMapInnerObserver2 = new SwitchMapInnerObserver(this);
+                do {
+                    switchMapInnerObserver = this.e.get();
+                    if (switchMapInnerObserver == h) {
+                        return;
+                    }
+                } while (!this.e.compareAndSet(switchMapInnerObserver, switchMapInnerObserver2));
+                if (switchMapInnerObserver != null) {
+                    switchMapInnerObserver.a();
+                }
+                completableSource.a(switchMapInnerObserver2);
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                this.g.dispose();
+                onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.g, disposable)) {
+                this.g = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+
+        void a(SwitchMapInnerObserver switchMapInnerObserver, Throwable th) {
+            if (this.e.compareAndSet(switchMapInnerObserver, null) && this.d.addThrowable(th)) {
+                if (this.c) {
+                    if (this.f) {
+                        this.a.onError(this.d.terminate());
+                        return;
+                    }
+                    return;
+                }
+                dispose();
+                Throwable terminate = this.d.terminate();
+                if (terminate != ExceptionHelper.a) {
+                    this.a.onError(terminate);
+                    return;
+                }
+                return;
+            }
+            RxJavaPlugins.b(th);
+        }
+
+        void a(SwitchMapInnerObserver switchMapInnerObserver) {
+            if (this.e.compareAndSet(switchMapInnerObserver, null) && this.f) {
+                Throwable terminate = this.d.terminate();
+                if (terminate == null) {
+                    this.a.onComplete();
+                } else {
+                    this.a.onError(terminate);
+                }
+            }
+        }
+    }
+}

sources/io/reactivex/internal/operators/mixed/ObservableSwitchMapMaybe.java

@@ -0,0 +1,213 @@
+package io.reactivex.internal.operators.mixed;
+
+import io.reactivex.MaybeObserver;
+import io.reactivex.MaybeSource;
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Function;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.util.AtomicThrowable;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableSwitchMapMaybe<T, R> extends Observable<R> {
+    final Observable<T> a;
+    final Function<? super T, ? extends MaybeSource<? extends R>> b;
+    final boolean c;
+
+    public ObservableSwitchMapMaybe(Observable<T> observable, Function<? super T, ? extends MaybeSource<? extends R>> function, boolean z) {
+        this.a = observable;
+        this.b = function;
+        this.c = z;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super R> observer) {
+        if (ScalarXMapZHelper.a(this.a, this.b, observer)) {
+            return;
+        }
+        this.a.subscribe(new SwitchMapMaybeMainObserver(observer, this.b, this.c));
+    }
+
+    static final class SwitchMapMaybeMainObserver<T, R> extends AtomicInteger implements Observer<T>, Disposable {
+        static final SwitchMapMaybeObserver<Object> i = new SwitchMapMaybeObserver<>(null);
+        final Observer<? super R> a;
+        final Function<? super T, ? extends MaybeSource<? extends R>> b;
+        final boolean c;
+        final AtomicThrowable d = new AtomicThrowable();
+        final AtomicReference<SwitchMapMaybeObserver<R>> e = new AtomicReference<>();
+        Disposable f;
+        volatile boolean g;
+        volatile boolean h;
+
+        static final class SwitchMapMaybeObserver<R> extends AtomicReference<Disposable> implements MaybeObserver<R> {
+            final SwitchMapMaybeMainObserver<?, R> a;
+            volatile R b;
+
+            SwitchMapMaybeObserver(SwitchMapMaybeMainObserver<?, R> switchMapMaybeMainObserver) {
+                this.a = switchMapMaybeMainObserver;
+            }
+
+            void a() {
+                DisposableHelper.dispose(this);
+            }
+
+            @Override // io.reactivex.MaybeObserver
+            public void onComplete() {
+                this.a.a(this);
+            }
+
+            @Override // io.reactivex.MaybeObserver
+            public void onError(Throwable th) {
+                this.a.a(this, th);
+            }
+
+            @Override // io.reactivex.MaybeObserver
+            public void onSubscribe(Disposable disposable) {
+                DisposableHelper.setOnce(this, disposable);
+            }
+
+            @Override // io.reactivex.MaybeObserver
+            public void onSuccess(R r) {
+                this.b = r;
+                this.a.b();
+            }
+        }
+
+        SwitchMapMaybeMainObserver(Observer<? super R> observer, Function<? super T, ? extends MaybeSource<? extends R>> function, boolean z) {
+            this.a = observer;
+            this.b = function;
+            this.c = z;
+        }
+
+        void a() {
+            SwitchMapMaybeObserver<Object> switchMapMaybeObserver = (SwitchMapMaybeObserver) this.e.getAndSet(i);
+            if (switchMapMaybeObserver == null || switchMapMaybeObserver == i) {
+                return;
+            }
+            switchMapMaybeObserver.a();
+        }
+
+        void b() {
+            if (getAndIncrement() != 0) {
+                return;
+            }
+            Observer<? super R> observer = this.a;
+            AtomicThrowable atomicThrowable = this.d;
+            AtomicReference<SwitchMapMaybeObserver<R>> atomicReference = this.e;
+            int i2 = 1;
+            while (!this.h) {
+                if (atomicThrowable.get() != null && !this.c) {
+                    observer.onError(atomicThrowable.terminate());
+                    return;
+                }
+                boolean z = this.g;
+                SwitchMapMaybeObserver<R> switchMapMaybeObserver = atomicReference.get();
+                boolean z2 = switchMapMaybeObserver == null;
+                if (z && z2) {
+                    Throwable terminate = atomicThrowable.terminate();
+                    if (terminate != null) {
+                        observer.onError(terminate);
+                        return;
+                    } else {
+                        observer.onComplete();
+                        return;
+                    }
+                }
+                if (z2 || switchMapMaybeObserver.b == null) {
+                    i2 = addAndGet(-i2);
+                    if (i2 == 0) {
+                        return;
+                    }
+                } else {
+                    atomicReference.compareAndSet(switchMapMaybeObserver, null);
+                    observer.onNext(switchMapMaybeObserver.b);
+                }
+            }
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.h = true;
+            this.f.dispose();
+            a();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.g = true;
+            b();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (!this.d.addThrowable(th)) {
+                RxJavaPlugins.b(th);
+                return;
+            }
+            if (!this.c) {
+                a();
+            }
+            this.g = true;
+            b();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            SwitchMapMaybeObserver<R> switchMapMaybeObserver;
+            SwitchMapMaybeObserver<R> switchMapMaybeObserver2 = this.e.get();
+            if (switchMapMaybeObserver2 != null) {
+                switchMapMaybeObserver2.a();
+            }
+            try {
+                MaybeSource<? extends R> apply = this.b.apply(t);
+                ObjectHelper.a(apply, "The mapper returned a null MaybeSource");
+                MaybeSource<? extends R> maybeSource = apply;
+                SwitchMapMaybeObserver<R> switchMapMaybeObserver3 = new SwitchMapMaybeObserver<>(this);
+                do {
+                    switchMapMaybeObserver = this.e.get();
+                    if (switchMapMaybeObserver == i) {
+                        return;
+                    }
+                } while (!this.e.compareAndSet(switchMapMaybeObserver, switchMapMaybeObserver3));
+                maybeSource.a(switchMapMaybeObserver3);
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                this.f.dispose();
+                this.e.getAndSet(i);
+                onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.f, disposable)) {
+                this.f = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+
+        void a(SwitchMapMaybeObserver<R> switchMapMaybeObserver, Throwable th) {
+            if (this.e.compareAndSet(switchMapMaybeObserver, null) && this.d.addThrowable(th)) {
+                if (!this.c) {
+                    this.f.dispose();
+                    a();
+                }
+                b();
+                return;
+            }
+            RxJavaPlugins.b(th);
+        }
+
+        void a(SwitchMapMaybeObserver<R> switchMapMaybeObserver) {
+            if (this.e.compareAndSet(switchMapMaybeObserver, null)) {
+                b();
+            }
+        }
+    }
+}

sources/io/reactivex/internal/operators/mixed/ObservableSwitchMapSingle.java

@@ -0,0 +1,202 @@
+package io.reactivex.internal.operators.mixed;
+
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.SingleObserver;
+import io.reactivex.SingleSource;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Function;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.util.AtomicThrowable;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableSwitchMapSingle<T, R> extends Observable<R> {
+    final Observable<T> a;
+    final Function<? super T, ? extends SingleSource<? extends R>> b;
+    final boolean c;
+
+    public ObservableSwitchMapSingle(Observable<T> observable, Function<? super T, ? extends SingleSource<? extends R>> function, boolean z) {
+        this.a = observable;
+        this.b = function;
+        this.c = z;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super R> observer) {
+        if (ScalarXMapZHelper.b(this.a, this.b, observer)) {
+            return;
+        }
+        this.a.subscribe(new SwitchMapSingleMainObserver(observer, this.b, this.c));
+    }
+
+    static final class SwitchMapSingleMainObserver<T, R> extends AtomicInteger implements Observer<T>, Disposable {
+        static final SwitchMapSingleObserver<Object> i = new SwitchMapSingleObserver<>(null);
+        final Observer<? super R> a;
+        final Function<? super T, ? extends SingleSource<? extends R>> b;
+        final boolean c;
+        final AtomicThrowable d = new AtomicThrowable();
+        final AtomicReference<SwitchMapSingleObserver<R>> e = new AtomicReference<>();
+        Disposable f;
+        volatile boolean g;
+        volatile boolean h;
+
+        static final class SwitchMapSingleObserver<R> extends AtomicReference<Disposable> implements SingleObserver<R> {
+            final SwitchMapSingleMainObserver<?, R> a;
+            volatile R b;
+
+            SwitchMapSingleObserver(SwitchMapSingleMainObserver<?, R> switchMapSingleMainObserver) {
+                this.a = switchMapSingleMainObserver;
+            }
+
+            void a() {
+                DisposableHelper.dispose(this);
+            }
+
+            @Override // io.reactivex.SingleObserver
+            public void onError(Throwable th) {
+                this.a.a(this, th);
+            }
+
+            @Override // io.reactivex.SingleObserver
+            public void onSubscribe(Disposable disposable) {
+                DisposableHelper.setOnce(this, disposable);
+            }
+
+            @Override // io.reactivex.SingleObserver
+            public void onSuccess(R r) {
+                this.b = r;
+                this.a.b();
+            }
+        }
+
+        SwitchMapSingleMainObserver(Observer<? super R> observer, Function<? super T, ? extends SingleSource<? extends R>> function, boolean z) {
+            this.a = observer;
+            this.b = function;
+            this.c = z;
+        }
+
+        void a() {
+            SwitchMapSingleObserver<Object> switchMapSingleObserver = (SwitchMapSingleObserver) this.e.getAndSet(i);
+            if (switchMapSingleObserver == null || switchMapSingleObserver == i) {
+                return;
+            }
+            switchMapSingleObserver.a();
+        }
+
+        void b() {
+            if (getAndIncrement() != 0) {
+                return;
+            }
+            Observer<? super R> observer = this.a;
+            AtomicThrowable atomicThrowable = this.d;
+            AtomicReference<SwitchMapSingleObserver<R>> atomicReference = this.e;
+            int i2 = 1;
+            while (!this.h) {
+                if (atomicThrowable.get() != null && !this.c) {
+                    observer.onError(atomicThrowable.terminate());
+                    return;
+                }
+                boolean z = this.g;
+                SwitchMapSingleObserver<R> switchMapSingleObserver = atomicReference.get();
+                boolean z2 = switchMapSingleObserver == null;
+                if (z && z2) {
+                    Throwable terminate = atomicThrowable.terminate();
+                    if (terminate != null) {
+                        observer.onError(terminate);
+                        return;
+                    } else {
+                        observer.onComplete();
+                        return;
+                    }
+                }
+                if (z2 || switchMapSingleObserver.b == null) {
+                    i2 = addAndGet(-i2);
+                    if (i2 == 0) {
+                        return;
+                    }
+                } else {
+                    atomicReference.compareAndSet(switchMapSingleObserver, null);
+                    observer.onNext(switchMapSingleObserver.b);
+                }
+            }
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.h = true;
+            this.f.dispose();
+            a();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.g = true;
+            b();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (!this.d.addThrowable(th)) {
+                RxJavaPlugins.b(th);
+                return;
+            }
+            if (!this.c) {
+                a();
+            }
+            this.g = true;
+            b();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            SwitchMapSingleObserver<R> switchMapSingleObserver;
+            SwitchMapSingleObserver<R> switchMapSingleObserver2 = this.e.get();
+            if (switchMapSingleObserver2 != null) {
+                switchMapSingleObserver2.a();
+            }
+            try {
+                SingleSource<? extends R> apply = this.b.apply(t);
+                ObjectHelper.a(apply, "The mapper returned a null SingleSource");
+                SingleSource<? extends R> singleSource = apply;
+                SwitchMapSingleObserver<R> switchMapSingleObserver3 = new SwitchMapSingleObserver<>(this);
+                do {
+                    switchMapSingleObserver = this.e.get();
+                    if (switchMapSingleObserver == i) {
+                        return;
+                    }
+                } while (!this.e.compareAndSet(switchMapSingleObserver, switchMapSingleObserver3));
+                singleSource.a(switchMapSingleObserver3);
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                this.f.dispose();
+                this.e.getAndSet(i);
+                onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.f, disposable)) {
+                this.f = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+
+        void a(SwitchMapSingleObserver<R> switchMapSingleObserver, Throwable th) {
+            if (this.e.compareAndSet(switchMapSingleObserver, null) && this.d.addThrowable(th)) {
+                if (!this.c) {
+                    this.f.dispose();
+                    a();
+                }
+                b();
+                return;
+            }
+            RxJavaPlugins.b(th);
+        }
+    }
+}

sources/io/reactivex/internal/operators/mixed/ScalarXMapZHelper.java

@@ -0,0 +1,93 @@
+package io.reactivex.internal.operators.mixed;
+
+import android.Manifest;
+import io.reactivex.CompletableObserver;
+import io.reactivex.CompletableSource;
+import io.reactivex.MaybeSource;
+import io.reactivex.Observer;
+import io.reactivex.SingleSource;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Function;
+import io.reactivex.internal.disposables.EmptyDisposable;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.operators.maybe.MaybeToObservable;
+import io.reactivex.internal.operators.single.SingleToObservable;
+import java.util.concurrent.Callable;
+
+/* loaded from: classes2.dex */
+final class ScalarXMapZHelper {
+    static <T> boolean a(Object obj, Function<? super T, ? extends CompletableSource> function, CompletableObserver completableObserver) {
+        if (!(obj instanceof Callable)) {
+            return false;
+        }
+        CompletableSource completableSource = null;
+        try {
+            Manifest manifest = (Object) ((Callable) obj).call();
+            if (manifest != null) {
+                CompletableSource apply = function.apply(manifest);
+                ObjectHelper.a(apply, "The mapper returned a null CompletableSource");
+                completableSource = apply;
+            }
+            if (completableSource == null) {
+                EmptyDisposable.complete(completableObserver);
+            } else {
+                completableSource.a(completableObserver);
+            }
+            return true;
+        } catch (Throwable th) {
+            Exceptions.b(th);
+            EmptyDisposable.error(th, completableObserver);
+            return true;
+        }
+    }
+
+    static <T, R> boolean b(Object obj, Function<? super T, ? extends SingleSource<? extends R>> function, Observer<? super R> observer) {
+        if (!(obj instanceof Callable)) {
+            return false;
+        }
+        SingleSource<? extends R> singleSource = null;
+        try {
+            Manifest manifest = (Object) ((Callable) obj).call();
+            if (manifest != null) {
+                SingleSource<? extends R> apply = function.apply(manifest);
+                ObjectHelper.a(apply, "The mapper returned a null SingleSource");
+                singleSource = apply;
+            }
+            if (singleSource == null) {
+                EmptyDisposable.complete(observer);
+            } else {
+                singleSource.a(SingleToObservable.a(observer));
+            }
+            return true;
+        } catch (Throwable th) {
+            Exceptions.b(th);
+            EmptyDisposable.error(th, observer);
+            return true;
+        }
+    }
+
+    static <T, R> boolean a(Object obj, Function<? super T, ? extends MaybeSource<? extends R>> function, Observer<? super R> observer) {
+        if (!(obj instanceof Callable)) {
+            return false;
+        }
+        MaybeSource<? extends R> maybeSource = null;
+        try {
+            Manifest manifest = (Object) ((Callable) obj).call();
+            if (manifest != null) {
+                MaybeSource<? extends R> apply = function.apply(manifest);
+                ObjectHelper.a(apply, "The mapper returned a null MaybeSource");
+                maybeSource = apply;
+            }
+            if (maybeSource == null) {
+                EmptyDisposable.complete(observer);
+            } else {
+                maybeSource.a(MaybeToObservable.a(observer));
+            }
+            return true;
+        } catch (Throwable th) {
+            Exceptions.b(th);
+            EmptyDisposable.error(th, observer);
+            return true;
+        }
+    }
+}

sources/io/reactivex/internal/operators/observable/AbstractObservableWithUpstream.java

@@ -0,0 +1,14 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Observable;
+import io.reactivex.ObservableSource;
+import io.reactivex.internal.fuseable.HasUpstreamObservableSource;
+
+/* loaded from: classes2.dex */
+abstract class AbstractObservableWithUpstream<T, U> extends Observable<U> implements HasUpstreamObservableSource<T> {
+    protected final ObservableSource<T> a;
+
+    AbstractObservableWithUpstream(ObservableSource<T> observableSource) {
+        this.a = observableSource;
+    }
+}

sources/io/reactivex/internal/operators/observable/BlockingObservableIterable.java

@@ -0,0 +1,131 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.queue.SpscLinkedArrayQueue;
+import io.reactivex.internal.util.BlockingHelper;
+import io.reactivex.internal.util.ExceptionHelper;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+/* loaded from: classes2.dex */
+public final class BlockingObservableIterable<T> implements Iterable<T> {
+    final ObservableSource<? extends T> a;
+    final int b;
+
+    static final class BlockingObservableIterator<T> extends AtomicReference<Disposable> implements Observer<T>, Iterator<T>, Disposable {
+        final SpscLinkedArrayQueue<T> a;
+        final Lock b = new ReentrantLock();
+        final Condition c = this.b.newCondition();
+        volatile boolean d;
+        Throwable e;
+
+        BlockingObservableIterator(int i) {
+            this.a = new SpscLinkedArrayQueue<>(i);
+        }
+
+        void a() {
+            this.b.lock();
+            try {
+                this.c.signalAll();
+            } finally {
+                this.b.unlock();
+            }
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            DisposableHelper.dispose(this);
+        }
+
+        @Override // java.util.Iterator
+        public boolean hasNext() {
+            while (true) {
+                boolean z = this.d;
+                boolean isEmpty = this.a.isEmpty();
+                if (z) {
+                    Throwable th = this.e;
+                    if (th != null) {
+                        throw ExceptionHelper.a(th);
+                    }
+                    if (isEmpty) {
+                        return false;
+                    }
+                }
+                if (!isEmpty) {
+                    return true;
+                }
+                try {
+                    BlockingHelper.a();
+                    this.b.lock();
+                    while (!this.d && this.a.isEmpty()) {
+                        try {
+                            this.c.await();
+                        } finally {
+                        }
+                    }
+                    this.b.unlock();
+                } catch (InterruptedException e) {
+                    DisposableHelper.dispose(this);
+                    a();
+                    throw ExceptionHelper.a(e);
+                }
+            }
+        }
+
+        @Override // java.util.Iterator
+        public T next() {
+            if (hasNext()) {
+                return this.a.poll();
+            }
+            throw new NoSuchElementException();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.d = true;
+            a();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            this.e = th;
+            this.d = true;
+            a();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            this.a.offer(t);
+            a();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            DisposableHelper.setOnce(this, disposable);
+        }
+
+        @Override // java.util.Iterator
+        public void remove() {
+            throw new UnsupportedOperationException("remove");
+        }
+    }
+
+    public BlockingObservableIterable(ObservableSource<? extends T> observableSource, int i) {
+        this.a = observableSource;
+        this.b = i;
+    }
+
+    @Override // java.lang.Iterable
+    public Iterator<T> iterator() {
+        BlockingObservableIterator blockingObservableIterator = new BlockingObservableIterator(this.b);
+        this.a.subscribe(blockingObservableIterator);
+        return blockingObservableIterator;
+    }
+}

sources/io/reactivex/internal/operators/observable/BlockingObservableLatest.java

@@ -0,0 +1,94 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Notification;
+import io.reactivex.Observable;
+import io.reactivex.ObservableSource;
+import io.reactivex.internal.util.BlockingHelper;
+import io.reactivex.internal.util.ExceptionHelper;
+import io.reactivex.observers.DisposableObserver;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import java.util.concurrent.Semaphore;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class BlockingObservableLatest<T> implements Iterable<T> {
+    final ObservableSource<T> a;
+
+    static final class BlockingObservableLatestIterator<T> extends DisposableObserver<Notification<T>> implements Iterator<T> {
+        Notification<T> b;
+        final Semaphore c = new Semaphore(0);
+        final AtomicReference<Notification<T>> d = new AtomicReference<>();
+
+        BlockingObservableLatestIterator() {
+        }
+
+        @Override // io.reactivex.Observer
+        /* renamed from: a, reason: merged with bridge method [inline-methods] */
+        public void onNext(Notification<T> notification) {
+            if (this.d.getAndSet(notification) == null) {
+                this.c.release();
+            }
+        }
+
+        @Override // java.util.Iterator
+        public boolean hasNext() {
+            Notification<T> notification = this.b;
+            if (notification != null && notification.d()) {
+                throw ExceptionHelper.a(this.b.a());
+            }
+            if (this.b == null) {
+                try {
+                    BlockingHelper.a();
+                    this.c.acquire();
+                    Notification<T> andSet = this.d.getAndSet(null);
+                    this.b = andSet;
+                    if (andSet.d()) {
+                        throw ExceptionHelper.a(andSet.a());
+                    }
+                } catch (InterruptedException e) {
+                    dispose();
+                    this.b = Notification.a((Throwable) e);
+                    throw ExceptionHelper.a(e);
+                }
+            }
+            return this.b.e();
+        }
+
+        @Override // java.util.Iterator
+        public T next() {
+            if (!hasNext()) {
+                throw new NoSuchElementException();
+            }
+            T b = this.b.b();
+            this.b = null;
+            return b;
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            RxJavaPlugins.b(th);
+        }
+
+        @Override // java.util.Iterator
+        public void remove() {
+            throw new UnsupportedOperationException("Read-only iterator.");
+        }
+    }
+
+    public BlockingObservableLatest(ObservableSource<T> observableSource) {
+        this.a = observableSource;
+    }
+
+    @Override // java.lang.Iterable
+    public Iterator<T> iterator() {
+        BlockingObservableLatestIterator blockingObservableLatestIterator = new BlockingObservableLatestIterator();
+        Observable.wrap(this.a).materialize().subscribe(blockingObservableLatestIterator);
+        return blockingObservableLatestIterator;
+    }
+}

sources/io/reactivex/internal/operators/observable/BlockingObservableMostRecent.java

@@ -0,0 +1,89 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+import io.reactivex.internal.util.ExceptionHelper;
+import io.reactivex.internal.util.NotificationLite;
+import io.reactivex.observers.DefaultObserver;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+/* loaded from: classes2.dex */
+public final class BlockingObservableMostRecent<T> implements Iterable<T> {
+    final ObservableSource<T> a;
+    final T b;
+
+    static final class MostRecentObserver<T> extends DefaultObserver<T> {
+        volatile Object b;
+
+        final class Iterator implements java.util.Iterator<T> {
+            private Object a;
+
+            Iterator() {
+            }
+
+            @Override // java.util.Iterator
+            public boolean hasNext() {
+                this.a = MostRecentObserver.this.b;
+                return !NotificationLite.isComplete(this.a);
+            }
+
+            @Override // java.util.Iterator
+            public T next() {
+                try {
+                    if (this.a == null) {
+                        this.a = MostRecentObserver.this.b;
+                    }
+                    if (NotificationLite.isComplete(this.a)) {
+                        throw new NoSuchElementException();
+                    }
+                    if (NotificationLite.isError(this.a)) {
+                        throw ExceptionHelper.a(NotificationLite.getError(this.a));
+                    }
+                    return (T) NotificationLite.getValue(this.a);
+                } finally {
+                    this.a = null;
+                }
+            }
+
+            @Override // java.util.Iterator
+            public void remove() {
+                throw new UnsupportedOperationException("Read only iterator");
+            }
+        }
+
+        MostRecentObserver(T t) {
+            this.b = NotificationLite.next(t);
+        }
+
+        public MostRecentObserver<T>.Iterator b() {
+            return new Iterator();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.b = NotificationLite.complete();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            this.b = NotificationLite.error(th);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            this.b = NotificationLite.next(t);
+        }
+    }
+
+    public BlockingObservableMostRecent(ObservableSource<T> observableSource, T t) {
+        this.a = observableSource;
+        this.b = t;
+    }
+
+    @Override // java.lang.Iterable
+    public Iterator<T> iterator() {
+        MostRecentObserver mostRecentObserver = new MostRecentObserver(this.b);
+        this.a.subscribe(mostRecentObserver);
+        return mostRecentObserver.b();
+    }
+}

sources/io/reactivex/internal/operators/observable/BlockingObservableNext.java

@@ -0,0 +1,138 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Notification;
+import io.reactivex.ObservableSource;
+import io.reactivex.internal.util.BlockingHelper;
+import io.reactivex.internal.util.ExceptionHelper;
+import io.reactivex.observers.DisposableObserver;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/* loaded from: classes2.dex */
+public final class BlockingObservableNext<T> implements Iterable<T> {
+    final ObservableSource<T> a;
+
+    static final class NextIterator<T> implements Iterator<T> {
+        private final NextObserver<T> a;
+        private final ObservableSource<T> b;
+        private T c;
+        private boolean d = true;
+        private boolean e = true;
+        private Throwable f;
+        private boolean g;
+
+        NextIterator(ObservableSource<T> observableSource, NextObserver<T> nextObserver) {
+            this.b = observableSource;
+            this.a = nextObserver;
+        }
+
+        private boolean a() {
+            if (!this.g) {
+                this.g = true;
+                this.a.b();
+                new ObservableMaterialize(this.b).subscribe(this.a);
+            }
+            try {
+                Notification<T> c = this.a.c();
+                if (c.e()) {
+                    this.e = false;
+                    this.c = c.b();
+                    return true;
+                }
+                this.d = false;
+                if (c.c()) {
+                    return false;
+                }
+                this.f = c.a();
+                throw ExceptionHelper.a(this.f);
+            } catch (InterruptedException e) {
+                this.a.dispose();
+                this.f = e;
+                throw ExceptionHelper.a(e);
+            }
+        }
+
+        @Override // java.util.Iterator
+        public boolean hasNext() {
+            Throwable th = this.f;
+            if (th != null) {
+                throw ExceptionHelper.a(th);
+            }
+            if (this.d) {
+                return !this.e || a();
+            }
+            return false;
+        }
+
+        @Override // java.util.Iterator
+        public T next() {
+            Throwable th = this.f;
+            if (th != null) {
+                throw ExceptionHelper.a(th);
+            }
+            if (!hasNext()) {
+                throw new NoSuchElementException("No more elements");
+            }
+            this.e = true;
+            return this.c;
+        }
+
+        @Override // java.util.Iterator
+        public void remove() {
+            throw new UnsupportedOperationException("Read only iterator");
+        }
+    }
+
+    static final class NextObserver<T> extends DisposableObserver<Notification<T>> {
+        private final BlockingQueue<Notification<T>> b = new ArrayBlockingQueue(1);
+        final AtomicInteger c = new AtomicInteger();
+
+        NextObserver() {
+        }
+
+        @Override // io.reactivex.Observer
+        /* renamed from: a, reason: merged with bridge method [inline-methods] */
+        public void onNext(Notification<T> notification) {
+            if (this.c.getAndSet(0) == 1 || !notification.e()) {
+                while (!this.b.offer(notification)) {
+                    Notification<T> poll = this.b.poll();
+                    if (poll != null && !poll.e()) {
+                        notification = poll;
+                    }
+                }
+            }
+        }
+
+        void b() {
+            this.c.set(1);
+        }
+
+        public Notification<T> c() throws InterruptedException {
+            b();
+            BlockingHelper.a();
+            return this.b.take();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            RxJavaPlugins.b(th);
+        }
+    }
+
+    public BlockingObservableNext(ObservableSource<T> observableSource) {
+        this.a = observableSource;
+    }
+
+    @Override // java.lang.Iterable
+    public Iterator<T> iterator() {
+        return new NextIterator(this.a, new NextObserver());
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableAll.java

@@ -0,0 +1,89 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Predicate;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.plugins.RxJavaPlugins;
+
+/* loaded from: classes2.dex */
+public final class ObservableAll<T> extends AbstractObservableWithUpstream<T, Boolean> {
+    final Predicate<? super T> b;
+
+    static final class AllObserver<T> implements Observer<T>, Disposable {
+        final Observer<? super Boolean> a;
+        final Predicate<? super T> b;
+        Disposable c;
+        boolean d;
+
+        AllObserver(Observer<? super Boolean> observer, Predicate<? super T> predicate) {
+            this.a = observer;
+            this.b = predicate;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.c.dispose();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            if (this.d) {
+                return;
+            }
+            this.d = true;
+            this.a.onNext(true);
+            this.a.onComplete();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (this.d) {
+                RxJavaPlugins.b(th);
+            } else {
+                this.d = true;
+                this.a.onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            if (this.d) {
+                return;
+            }
+            try {
+                if (this.b.a(t)) {
+                    return;
+                }
+                this.d = true;
+                this.c.dispose();
+                this.a.onNext(false);
+                this.a.onComplete();
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                this.c.dispose();
+                onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.c, disposable)) {
+                this.c = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+    }
+
+    public ObservableAll(ObservableSource<T> observableSource, Predicate<? super T> predicate) {
+        super(observableSource);
+        this.b = predicate;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super Boolean> observer) {
+        this.a.subscribe(new AllObserver(observer, this.b));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableAllSingle.java

@@ -0,0 +1,97 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Observable;
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.Single;
+import io.reactivex.SingleObserver;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Predicate;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.fuseable.FuseToObservable;
+import io.reactivex.plugins.RxJavaPlugins;
+
+/* loaded from: classes2.dex */
+public final class ObservableAllSingle<T> extends Single<Boolean> implements FuseToObservable<Boolean> {
+    final ObservableSource<T> a;
+    final Predicate<? super T> b;
+
+    static final class AllObserver<T> implements Observer<T>, Disposable {
+        final SingleObserver<? super Boolean> a;
+        final Predicate<? super T> b;
+        Disposable c;
+        boolean d;
+
+        AllObserver(SingleObserver<? super Boolean> singleObserver, Predicate<? super T> predicate) {
+            this.a = singleObserver;
+            this.b = predicate;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.c.dispose();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            if (this.d) {
+                return;
+            }
+            this.d = true;
+            this.a.onSuccess(true);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (this.d) {
+                RxJavaPlugins.b(th);
+            } else {
+                this.d = true;
+                this.a.onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            if (this.d) {
+                return;
+            }
+            try {
+                if (this.b.a(t)) {
+                    return;
+                }
+                this.d = true;
+                this.c.dispose();
+                this.a.onSuccess(false);
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                this.c.dispose();
+                onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.c, disposable)) {
+                this.c = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+    }
+
+    public ObservableAllSingle(ObservableSource<T> observableSource, Predicate<? super T> predicate) {
+        this.a = observableSource;
+        this.b = predicate;
+    }
+
+    @Override // io.reactivex.internal.fuseable.FuseToObservable
+    public Observable<Boolean> a() {
+        return RxJavaPlugins.a(new ObservableAll(this.a, this.b));
+    }
+
+    @Override // io.reactivex.Single
+    protected void b(SingleObserver<? super Boolean> singleObserver) {
+        this.a.subscribe(new AllObserver(singleObserver, this.b));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableAmb.java

@@ -0,0 +1,176 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Observable;
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.disposables.EmptyDisposable;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableAmb<T> extends Observable<T> {
+    final ObservableSource<? extends T>[] a;
+    final Iterable<? extends ObservableSource<? extends T>> b;
+
+    static final class AmbInnerObserver<T> extends AtomicReference<Disposable> implements Observer<T> {
+        final AmbCoordinator<T> a;
+        final int b;
+        final Observer<? super T> c;
+        boolean d;
+
+        AmbInnerObserver(AmbCoordinator<T> ambCoordinator, int i, Observer<? super T> observer) {
+            this.a = ambCoordinator;
+            this.b = i;
+            this.c = observer;
+        }
+
+        public void a() {
+            DisposableHelper.dispose(this);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            if (this.d) {
+                this.c.onComplete();
+            } else if (this.a.a(this.b)) {
+                this.d = true;
+                this.c.onComplete();
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (this.d) {
+                this.c.onError(th);
+            } else if (!this.a.a(this.b)) {
+                RxJavaPlugins.b(th);
+            } else {
+                this.d = true;
+                this.c.onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            if (this.d) {
+                this.c.onNext(t);
+            } else if (!this.a.a(this.b)) {
+                get().dispose();
+            } else {
+                this.d = true;
+                this.c.onNext(t);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            DisposableHelper.setOnce(this, disposable);
+        }
+    }
+
+    public ObservableAmb(ObservableSource<? extends T>[] observableSourceArr, Iterable<? extends ObservableSource<? extends T>> iterable) {
+        this.a = observableSourceArr;
+        this.b = iterable;
+    }
+
+    @Override // io.reactivex.Observable
+    public void subscribeActual(Observer<? super T> observer) {
+        int length;
+        ObservableSource<? extends T>[] observableSourceArr = this.a;
+        if (observableSourceArr == null) {
+            observableSourceArr = new Observable[8];
+            try {
+                length = 0;
+                for (ObservableSource<? extends T> observableSource : this.b) {
+                    if (observableSource == null) {
+                        EmptyDisposable.error(new NullPointerException("One of the sources is null"), observer);
+                        return;
+                    }
+                    if (length == observableSourceArr.length) {
+                        ObservableSource<? extends T>[] observableSourceArr2 = new ObservableSource[(length >> 2) + length];
+                        System.arraycopy(observableSourceArr, 0, observableSourceArr2, 0, length);
+                        observableSourceArr = observableSourceArr2;
+                    }
+                    int i = length + 1;
+                    observableSourceArr[length] = observableSource;
+                    length = i;
+                }
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                EmptyDisposable.error(th, observer);
+                return;
+            }
+        } else {
+            length = observableSourceArr.length;
+        }
+        if (length == 0) {
+            EmptyDisposable.complete(observer);
+        } else if (length == 1) {
+            observableSourceArr[0].subscribe(observer);
+        } else {
+            new AmbCoordinator(observer, length).a(observableSourceArr);
+        }
+    }
+
+    static final class AmbCoordinator<T> implements Disposable {
+        final Observer<? super T> a;
+        final AmbInnerObserver<T>[] b;
+        final AtomicInteger c = new AtomicInteger();
+
+        AmbCoordinator(Observer<? super T> observer, int i) {
+            this.a = observer;
+            this.b = new AmbInnerObserver[i];
+        }
+
+        public void a(ObservableSource<? extends T>[] observableSourceArr) {
+            AmbInnerObserver<T>[] ambInnerObserverArr = this.b;
+            int length = ambInnerObserverArr.length;
+            int i = 0;
+            while (i < length) {
+                int i2 = i + 1;
+                ambInnerObserverArr[i] = new AmbInnerObserver<>(this, i2, this.a);
+                i = i2;
+            }
+            this.c.lazySet(0);
+            this.a.onSubscribe(this);
+            for (int i3 = 0; i3 < length && this.c.get() == 0; i3++) {
+                observableSourceArr[i3].subscribe(ambInnerObserverArr[i3]);
+            }
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            if (this.c.get() != -1) {
+                this.c.lazySet(-1);
+                for (AmbInnerObserver<T> ambInnerObserver : this.b) {
+                    ambInnerObserver.a();
+                }
+            }
+        }
+
+        public boolean a(int i) {
+            int i2 = this.c.get();
+            int i3 = 0;
+            if (i2 != 0) {
+                return i2 == i;
+            }
+            if (!this.c.compareAndSet(0, i)) {
+                return false;
+            }
+            AmbInnerObserver<T>[] ambInnerObserverArr = this.b;
+            int length = ambInnerObserverArr.length;
+            while (i3 < length) {
+                int i4 = i3 + 1;
+                if (i4 != i) {
+                    ambInnerObserverArr[i3].a();
+                }
+                i3 = i4;
+            }
+            return true;
+        }
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableAny.java

@@ -0,0 +1,88 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Predicate;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.plugins.RxJavaPlugins;
+
+/* loaded from: classes2.dex */
+public final class ObservableAny<T> extends AbstractObservableWithUpstream<T, Boolean> {
+    final Predicate<? super T> b;
+
+    static final class AnyObserver<T> implements Observer<T>, Disposable {
+        final Observer<? super Boolean> a;
+        final Predicate<? super T> b;
+        Disposable c;
+        boolean d;
+
+        AnyObserver(Observer<? super Boolean> observer, Predicate<? super T> predicate) {
+            this.a = observer;
+            this.b = predicate;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.c.dispose();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            if (this.d) {
+                return;
+            }
+            this.d = true;
+            this.a.onNext(false);
+            this.a.onComplete();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (this.d) {
+                RxJavaPlugins.b(th);
+            } else {
+                this.d = true;
+                this.a.onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            if (this.d) {
+                return;
+            }
+            try {
+                if (this.b.a(t)) {
+                    this.d = true;
+                    this.c.dispose();
+                    this.a.onNext(true);
+                    this.a.onComplete();
+                }
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                this.c.dispose();
+                onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.c, disposable)) {
+                this.c = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+    }
+
+    public ObservableAny(ObservableSource<T> observableSource, Predicate<? super T> predicate) {
+        super(observableSource);
+        this.b = predicate;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super Boolean> observer) {
+        this.a.subscribe(new AnyObserver(observer, this.b));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableAnySingle.java

@@ -0,0 +1,96 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Observable;
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.Single;
+import io.reactivex.SingleObserver;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Predicate;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.fuseable.FuseToObservable;
+import io.reactivex.plugins.RxJavaPlugins;
+
+/* loaded from: classes2.dex */
+public final class ObservableAnySingle<T> extends Single<Boolean> implements FuseToObservable<Boolean> {
+    final ObservableSource<T> a;
+    final Predicate<? super T> b;
+
+    static final class AnyObserver<T> implements Observer<T>, Disposable {
+        final SingleObserver<? super Boolean> a;
+        final Predicate<? super T> b;
+        Disposable c;
+        boolean d;
+
+        AnyObserver(SingleObserver<? super Boolean> singleObserver, Predicate<? super T> predicate) {
+            this.a = singleObserver;
+            this.b = predicate;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.c.dispose();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            if (this.d) {
+                return;
+            }
+            this.d = true;
+            this.a.onSuccess(false);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (this.d) {
+                RxJavaPlugins.b(th);
+            } else {
+                this.d = true;
+                this.a.onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            if (this.d) {
+                return;
+            }
+            try {
+                if (this.b.a(t)) {
+                    this.d = true;
+                    this.c.dispose();
+                    this.a.onSuccess(true);
+                }
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                this.c.dispose();
+                onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.c, disposable)) {
+                this.c = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+    }
+
+    public ObservableAnySingle(ObservableSource<T> observableSource, Predicate<? super T> predicate) {
+        this.a = observableSource;
+        this.b = predicate;
+    }
+
+    @Override // io.reactivex.internal.fuseable.FuseToObservable
+    public Observable<Boolean> a() {
+        return RxJavaPlugins.a(new ObservableAny(this.a, this.b));
+    }
+
+    @Override // io.reactivex.Single
+    protected void b(SingleObserver<? super Boolean> singleObserver) {
+        this.a.subscribe(new AnyObserver(singleObserver, this.b));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableBlockingSubscribe.java

@@ -0,0 +1,58 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.functions.Action;
+import io.reactivex.functions.Consumer;
+import io.reactivex.internal.functions.Functions;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.observers.BlockingObserver;
+import io.reactivex.internal.observers.LambdaObserver;
+import io.reactivex.internal.util.BlockingHelper;
+import io.reactivex.internal.util.BlockingIgnoringReceiver;
+import io.reactivex.internal.util.ExceptionHelper;
+import io.reactivex.internal.util.NotificationLite;
+import java.util.concurrent.LinkedBlockingQueue;
+
+/* loaded from: classes2.dex */
+public final class ObservableBlockingSubscribe {
+    public static <T> void a(ObservableSource<? extends T> observableSource, Observer<? super T> observer) {
+        LinkedBlockingQueue linkedBlockingQueue = new LinkedBlockingQueue();
+        BlockingObserver blockingObserver = new BlockingObserver(linkedBlockingQueue);
+        observer.onSubscribe(blockingObserver);
+        observableSource.subscribe(blockingObserver);
+        while (!blockingObserver.isDisposed()) {
+            Object poll = linkedBlockingQueue.poll();
+            if (poll == null) {
+                try {
+                    poll = linkedBlockingQueue.take();
+                } catch (InterruptedException e) {
+                    blockingObserver.dispose();
+                    observer.onError(e);
+                    return;
+                }
+            }
+            if (blockingObserver.isDisposed() || observableSource == BlockingObserver.TERMINATED || NotificationLite.acceptFull(poll, observer)) {
+                return;
+            }
+        }
+    }
+
+    public static <T> void a(ObservableSource<? extends T> observableSource) {
+        BlockingIgnoringReceiver blockingIgnoringReceiver = new BlockingIgnoringReceiver();
+        LambdaObserver lambdaObserver = new LambdaObserver(Functions.d(), blockingIgnoringReceiver, blockingIgnoringReceiver, Functions.d());
+        observableSource.subscribe(lambdaObserver);
+        BlockingHelper.a(blockingIgnoringReceiver, lambdaObserver);
+        Throwable th = blockingIgnoringReceiver.a;
+        if (th != null) {
+            throw ExceptionHelper.a(th);
+        }
+    }
+
+    public static <T> void a(ObservableSource<? extends T> observableSource, Consumer<? super T> consumer, Consumer<? super Throwable> consumer2, Action action) {
+        ObjectHelper.a(consumer, "onNext is null");
+        ObjectHelper.a(consumer2, "onError is null");
+        ObjectHelper.a(action, "onComplete is null");
+        a(observableSource, new LambdaObserver(consumer, consumer2, action, Functions.d()));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableBuffer.java

@@ -0,0 +1,194 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.disposables.EmptyDisposable;
+import io.reactivex.internal.functions.ObjectHelper;
+import java.util.ArrayDeque;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.concurrent.Callable;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/* loaded from: classes2.dex */
+public final class ObservableBuffer<T, U extends Collection<? super T>> extends AbstractObservableWithUpstream<T, U> {
+    final int b;
+    final int c;
+    final Callable<U> d;
+
+    static final class BufferExactObserver<T, U extends Collection<? super T>> implements Observer<T>, Disposable {
+        final Observer<? super U> a;
+        final int b;
+        final Callable<U> c;
+        U d;
+        int e;
+        Disposable f;
+
+        BufferExactObserver(Observer<? super U> observer, int i, Callable<U> callable) {
+            this.a = observer;
+            this.b = i;
+            this.c = callable;
+        }
+
+        boolean a() {
+            try {
+                U call = this.c.call();
+                ObjectHelper.a(call, "Empty buffer supplied");
+                this.d = call;
+                return true;
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                this.d = null;
+                Disposable disposable = this.f;
+                if (disposable == null) {
+                    EmptyDisposable.error(th, this.a);
+                    return false;
+                }
+                disposable.dispose();
+                this.a.onError(th);
+                return false;
+            }
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.f.dispose();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            U u = this.d;
+            if (u != null) {
+                this.d = null;
+                if (!u.isEmpty()) {
+                    this.a.onNext(u);
+                }
+                this.a.onComplete();
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            this.d = null;
+            this.a.onError(th);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            U u = this.d;
+            if (u != null) {
+                u.add(t);
+                int i = this.e + 1;
+                this.e = i;
+                if (i >= this.b) {
+                    this.a.onNext(u);
+                    this.e = 0;
+                    a();
+                }
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.f, disposable)) {
+                this.f = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+    }
+
+    static final class BufferSkipObserver<T, U extends Collection<? super T>> extends AtomicBoolean implements Observer<T>, Disposable {
+        final Observer<? super U> a;
+        final int b;
+        final int c;
+        final Callable<U> d;
+        Disposable e;
+        final ArrayDeque<U> f = new ArrayDeque<>();
+        long g;
+
+        BufferSkipObserver(Observer<? super U> observer, int i, int i2, Callable<U> callable) {
+            this.a = observer;
+            this.b = i;
+            this.c = i2;
+            this.d = callable;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.e.dispose();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            while (!this.f.isEmpty()) {
+                this.a.onNext(this.f.poll());
+            }
+            this.a.onComplete();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            this.f.clear();
+            this.a.onError(th);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            long j = this.g;
+            this.g = 1 + j;
+            if (j % this.c == 0) {
+                try {
+                    U call = this.d.call();
+                    ObjectHelper.a(call, "The bufferSupplier returned a null collection. Null values are generally not allowed in 2.x operators and sources.");
+                    this.f.offer(call);
+                } catch (Throwable th) {
+                    this.f.clear();
+                    this.e.dispose();
+                    this.a.onError(th);
+                    return;
+                }
+            }
+            Iterator<U> it = this.f.iterator();
+            while (it.hasNext()) {
+                U next = it.next();
+                next.add(t);
+                if (this.b <= next.size()) {
+                    it.remove();
+                    this.a.onNext(next);
+                }
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.e, disposable)) {
+                this.e = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+    }
+
+    public ObservableBuffer(ObservableSource<T> observableSource, int i, int i2, Callable<U> callable) {
+        super(observableSource);
+        this.b = i;
+        this.c = i2;
+        this.d = callable;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super U> observer) {
+        int i = this.c;
+        int i2 = this.b;
+        if (i != i2) {
+            this.a.subscribe(new BufferSkipObserver(observer, i2, i, this.d));
+            return;
+        }
+        BufferExactObserver bufferExactObserver = new BufferExactObserver(observer, i2, this.d);
+        if (bufferExactObserver.a()) {
+            this.a.subscribe(bufferExactObserver);
+        }
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableBufferBoundary.java

@@ -0,0 +1,315 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Observable;
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.CompositeDisposable;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Function;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.queue.SpscLinkedArrayQueue;
+import io.reactivex.internal.util.AtomicThrowable;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableBufferBoundary<T, U extends Collection<? super T>, Open, Close> extends AbstractObservableWithUpstream<T, U> {
+    final Callable<U> b;
+    final ObservableSource<? extends Open> c;
+    final Function<? super Open, ? extends ObservableSource<? extends Close>> d;
+
+    static final class BufferCloseObserver<T, C extends Collection<? super T>> extends AtomicReference<Disposable> implements Observer<Object>, Disposable {
+        final BufferBoundaryObserver<T, C, ?, ?> a;
+        final long b;
+
+        BufferCloseObserver(BufferBoundaryObserver<T, C, ?, ?> bufferBoundaryObserver, long j) {
+            this.a = bufferBoundaryObserver;
+            this.b = j;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            DisposableHelper.dispose(this);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            Disposable disposable = get();
+            DisposableHelper disposableHelper = DisposableHelper.DISPOSED;
+            if (disposable != disposableHelper) {
+                lazySet(disposableHelper);
+                this.a.a(this, this.b);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            Disposable disposable = get();
+            DisposableHelper disposableHelper = DisposableHelper.DISPOSED;
+            if (disposable == disposableHelper) {
+                RxJavaPlugins.b(th);
+            } else {
+                lazySet(disposableHelper);
+                this.a.a(this, th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(Object obj) {
+            Disposable disposable = get();
+            DisposableHelper disposableHelper = DisposableHelper.DISPOSED;
+            if (disposable != disposableHelper) {
+                lazySet(disposableHelper);
+                disposable.dispose();
+                this.a.a(this, this.b);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            DisposableHelper.setOnce(this, disposable);
+        }
+    }
+
+    public ObservableBufferBoundary(ObservableSource<T> observableSource, ObservableSource<? extends Open> observableSource2, Function<? super Open, ? extends ObservableSource<? extends Close>> function, Callable<U> callable) {
+        super(observableSource);
+        this.c = observableSource2;
+        this.d = function;
+        this.b = callable;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super U> observer) {
+        BufferBoundaryObserver bufferBoundaryObserver = new BufferBoundaryObserver(observer, this.c, this.d, this.b);
+        observer.onSubscribe(bufferBoundaryObserver);
+        this.a.subscribe(bufferBoundaryObserver);
+    }
+
+    static final class BufferBoundaryObserver<T, C extends Collection<? super T>, Open, Close> extends AtomicInteger implements Observer<T>, Disposable {
+        final Observer<? super C> a;
+        final Callable<C> b;
+        final ObservableSource<? extends Open> c;
+        final Function<? super Open, ? extends ObservableSource<? extends Close>> d;
+        volatile boolean h;
+        volatile boolean j;
+        long k;
+        final SpscLinkedArrayQueue<C> i = new SpscLinkedArrayQueue<>(Observable.bufferSize());
+        final CompositeDisposable e = new CompositeDisposable();
+        final AtomicReference<Disposable> f = new AtomicReference<>();
+        Map<Long, C> l = new LinkedHashMap();
+        final AtomicThrowable g = new AtomicThrowable();
+
+        static final class BufferOpenObserver<Open> extends AtomicReference<Disposable> implements Observer<Open>, Disposable {
+            final BufferBoundaryObserver<?, ?, Open, ?> a;
+
+            BufferOpenObserver(BufferBoundaryObserver<?, ?, Open, ?> bufferBoundaryObserver) {
+                this.a = bufferBoundaryObserver;
+            }
+
+            @Override // io.reactivex.disposables.Disposable
+            public void dispose() {
+                DisposableHelper.dispose(this);
+            }
+
+            @Override // io.reactivex.Observer
+            public void onComplete() {
+                lazySet(DisposableHelper.DISPOSED);
+                this.a.a((BufferOpenObserver) this);
+            }
+
+            @Override // io.reactivex.Observer
+            public void onError(Throwable th) {
+                lazySet(DisposableHelper.DISPOSED);
+                this.a.a(this, th);
+            }
+
+            @Override // io.reactivex.Observer
+            public void onNext(Open open) {
+                this.a.a((BufferBoundaryObserver<?, ?, Open, ?>) open);
+            }
+
+            @Override // io.reactivex.Observer
+            public void onSubscribe(Disposable disposable) {
+                DisposableHelper.setOnce(this, disposable);
+            }
+        }
+
+        BufferBoundaryObserver(Observer<? super C> observer, ObservableSource<? extends Open> observableSource, Function<? super Open, ? extends ObservableSource<? extends Close>> function, Callable<C> callable) {
+            this.a = observer;
+            this.b = callable;
+            this.c = observableSource;
+            this.d = function;
+        }
+
+        void a(Open open) {
+            try {
+                C call = this.b.call();
+                ObjectHelper.a(call, "The bufferSupplier returned a null Collection");
+                C c = call;
+                ObservableSource<? extends Close> apply = this.d.apply(open);
+                ObjectHelper.a(apply, "The bufferClose returned a null ObservableSource");
+                ObservableSource<? extends Close> observableSource = apply;
+                long j = this.k;
+                this.k = 1 + j;
+                synchronized (this) {
+                    Map<Long, C> map = this.l;
+                    if (map == null) {
+                        return;
+                    }
+                    map.put(Long.valueOf(j), c);
+                    BufferCloseObserver bufferCloseObserver = new BufferCloseObserver(this, j);
+                    this.e.b(bufferCloseObserver);
+                    observableSource.subscribe(bufferCloseObserver);
+                }
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                DisposableHelper.dispose(this.f);
+                onError(th);
+            }
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            if (DisposableHelper.dispose(this.f)) {
+                this.j = true;
+                this.e.dispose();
+                synchronized (this) {
+                    this.l = null;
+                }
+                if (getAndIncrement() != 0) {
+                    this.i.clear();
+                }
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.e.dispose();
+            synchronized (this) {
+                Map<Long, C> map = this.l;
+                if (map == null) {
+                    return;
+                }
+                Iterator<C> it = map.values().iterator();
+                while (it.hasNext()) {
+                    this.i.offer(it.next());
+                }
+                this.l = null;
+                this.h = true;
+                a();
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (!this.g.addThrowable(th)) {
+                RxJavaPlugins.b(th);
+                return;
+            }
+            this.e.dispose();
+            synchronized (this) {
+                this.l = null;
+            }
+            this.h = true;
+            a();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            synchronized (this) {
+                Map<Long, C> map = this.l;
+                if (map == null) {
+                    return;
+                }
+                Iterator<C> it = map.values().iterator();
+                while (it.hasNext()) {
+                    it.next().add(t);
+                }
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.setOnce(this.f, disposable)) {
+                BufferOpenObserver bufferOpenObserver = new BufferOpenObserver(this);
+                this.e.b(bufferOpenObserver);
+                this.c.subscribe(bufferOpenObserver);
+            }
+        }
+
+        void a(BufferOpenObserver<Open> bufferOpenObserver) {
+            this.e.c(bufferOpenObserver);
+            if (this.e.c() == 0) {
+                DisposableHelper.dispose(this.f);
+                this.h = true;
+                a();
+            }
+        }
+
+        void a(BufferCloseObserver<T, C> bufferCloseObserver, long j) {
+            boolean z;
+            this.e.c(bufferCloseObserver);
+            if (this.e.c() == 0) {
+                DisposableHelper.dispose(this.f);
+                z = true;
+            } else {
+                z = false;
+            }
+            synchronized (this) {
+                if (this.l == null) {
+                    return;
+                }
+                this.i.offer(this.l.remove(Long.valueOf(j)));
+                if (z) {
+                    this.h = true;
+                }
+                a();
+            }
+        }
+
+        void a(Disposable disposable, Throwable th) {
+            DisposableHelper.dispose(this.f);
+            this.e.c(disposable);
+            onError(th);
+        }
+
+        void a() {
+            if (getAndIncrement() != 0) {
+                return;
+            }
+            Observer<? super C> observer = this.a;
+            SpscLinkedArrayQueue<C> spscLinkedArrayQueue = this.i;
+            int i = 1;
+            while (!this.j) {
+                boolean z = this.h;
+                if (z && this.g.get() != null) {
+                    spscLinkedArrayQueue.clear();
+                    observer.onError(this.g.terminate());
+                    return;
+                }
+                C poll = spscLinkedArrayQueue.poll();
+                boolean z2 = poll == null;
+                if (z && z2) {
+                    observer.onComplete();
+                    return;
+                } else if (z2) {
+                    i = addAndGet(-i);
+                    if (i == 0) {
+                        return;
+                    }
+                } else {
+                    observer.onNext(poll);
+                }
+            }
+            spscLinkedArrayQueue.clear();
+        }
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableBufferBoundarySupplier.java

@@ -0,0 +1,217 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.disposables.EmptyDisposable;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.observers.QueueDrainObserver;
+import io.reactivex.internal.queue.MpscLinkedQueue;
+import io.reactivex.internal.util.QueueDrainHelper;
+import io.reactivex.observers.DisposableObserver;
+import io.reactivex.observers.SerializedObserver;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.Collection;
+import java.util.concurrent.Callable;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableBufferBoundarySupplier<T, U extends Collection<? super T>, B> extends AbstractObservableWithUpstream<T, U> {
+    final Callable<? extends ObservableSource<B>> b;
+    final Callable<U> c;
+
+    static final class BufferBoundaryObserver<T, U extends Collection<? super T>, B> extends DisposableObserver<B> {
+        final BufferBoundarySupplierObserver<T, U, B> b;
+        boolean c;
+
+        BufferBoundaryObserver(BufferBoundarySupplierObserver<T, U, B> bufferBoundarySupplierObserver) {
+            this.b = bufferBoundarySupplierObserver;
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            if (this.c) {
+                return;
+            }
+            this.c = true;
+            this.b.j();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (this.c) {
+                RxJavaPlugins.b(th);
+            } else {
+                this.c = true;
+                this.b.onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(B b) {
+            if (this.c) {
+                return;
+            }
+            this.c = true;
+            dispose();
+            this.b.j();
+        }
+    }
+
+    static final class BufferBoundarySupplierObserver<T, U extends Collection<? super T>, B> extends QueueDrainObserver<T, U, U> implements Observer<T>, Disposable {
+        final Callable<U> g;
+        final Callable<? extends ObservableSource<B>> h;
+        Disposable i;
+        final AtomicReference<Disposable> j;
+        U k;
+
+        BufferBoundarySupplierObserver(Observer<? super U> observer, Callable<U> callable, Callable<? extends ObservableSource<B>> callable2) {
+            super(observer, new MpscLinkedQueue());
+            this.j = new AtomicReference<>();
+            this.g = callable;
+            this.h = callable2;
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // io.reactivex.internal.observers.QueueDrainObserver, io.reactivex.internal.util.ObservableQueueDrain
+        public /* bridge */ /* synthetic */ void a(Observer observer, Object obj) {
+            a((Observer<? super Observer>) observer, (Observer) obj);
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            if (this.d) {
+                return;
+            }
+            this.d = true;
+            this.i.dispose();
+            f();
+            if (d()) {
+                this.c.clear();
+            }
+        }
+
+        void f() {
+            DisposableHelper.dispose(this.j);
+        }
+
+        void j() {
+            try {
+                U call = this.g.call();
+                ObjectHelper.a(call, "The buffer supplied is null");
+                U u = call;
+                try {
+                    ObservableSource<B> call2 = this.h.call();
+                    ObjectHelper.a(call2, "The boundary ObservableSource supplied is null");
+                    ObservableSource<B> observableSource = call2;
+                    BufferBoundaryObserver bufferBoundaryObserver = new BufferBoundaryObserver(this);
+                    if (DisposableHelper.replace(this.j, bufferBoundaryObserver)) {
+                        synchronized (this) {
+                            U u2 = this.k;
+                            if (u2 == null) {
+                                return;
+                            }
+                            this.k = u;
+                            observableSource.subscribe(bufferBoundaryObserver);
+                            a(u2, false, this);
+                        }
+                    }
+                } catch (Throwable th) {
+                    Exceptions.b(th);
+                    this.d = true;
+                    this.i.dispose();
+                    this.b.onError(th);
+                }
+            } catch (Throwable th2) {
+                Exceptions.b(th2);
+                dispose();
+                this.b.onError(th2);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            synchronized (this) {
+                U u = this.k;
+                if (u == null) {
+                    return;
+                }
+                this.k = null;
+                this.c.offer(u);
+                this.e = true;
+                if (d()) {
+                    QueueDrainHelper.a(this.c, this.b, false, this, this);
+                }
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            dispose();
+            this.b.onError(th);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            synchronized (this) {
+                U u = this.k;
+                if (u == null) {
+                    return;
+                }
+                u.add(t);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.i, disposable)) {
+                this.i = disposable;
+                Observer<? super V> observer = this.b;
+                try {
+                    U call = this.g.call();
+                    ObjectHelper.a(call, "The buffer supplied is null");
+                    this.k = call;
+                    try {
+                        ObservableSource<B> call2 = this.h.call();
+                        ObjectHelper.a(call2, "The boundary ObservableSource supplied is null");
+                        ObservableSource<B> observableSource = call2;
+                        BufferBoundaryObserver bufferBoundaryObserver = new BufferBoundaryObserver(this);
+                        this.j.set(bufferBoundaryObserver);
+                        observer.onSubscribe(this);
+                        if (this.d) {
+                            return;
+                        }
+                        observableSource.subscribe(bufferBoundaryObserver);
+                    } catch (Throwable th) {
+                        Exceptions.b(th);
+                        this.d = true;
+                        disposable.dispose();
+                        EmptyDisposable.error(th, observer);
+                    }
+                } catch (Throwable th2) {
+                    Exceptions.b(th2);
+                    this.d = true;
+                    disposable.dispose();
+                    EmptyDisposable.error(th2, observer);
+                }
+            }
+        }
+
+        public void a(Observer<? super U> observer, U u) {
+            this.b.onNext(u);
+        }
+    }
+
+    public ObservableBufferBoundarySupplier(ObservableSource<T> observableSource, Callable<? extends ObservableSource<B>> callable, Callable<U> callable2) {
+        super(observableSource);
+        this.b = callable;
+        this.c = callable2;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super U> observer) {
+        this.a.subscribe(new BufferBoundarySupplierObserver(new SerializedObserver(observer), this.c, this.b));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableBufferExactBoundary.java

@@ -0,0 +1,170 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.disposables.EmptyDisposable;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.observers.QueueDrainObserver;
+import io.reactivex.internal.queue.MpscLinkedQueue;
+import io.reactivex.internal.util.QueueDrainHelper;
+import io.reactivex.observers.DisposableObserver;
+import io.reactivex.observers.SerializedObserver;
+import java.util.Collection;
+import java.util.concurrent.Callable;
+
+/* loaded from: classes2.dex */
+public final class ObservableBufferExactBoundary<T, U extends Collection<? super T>, B> extends AbstractObservableWithUpstream<T, U> {
+    final ObservableSource<B> b;
+    final Callable<U> c;
+
+    static final class BufferBoundaryObserver<T, U extends Collection<? super T>, B> extends DisposableObserver<B> {
+        final BufferExactBoundaryObserver<T, U, B> b;
+
+        BufferBoundaryObserver(BufferExactBoundaryObserver<T, U, B> bufferExactBoundaryObserver) {
+            this.b = bufferExactBoundaryObserver;
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.b.onComplete();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            this.b.onError(th);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(B b) {
+            this.b.f();
+        }
+    }
+
+    static final class BufferExactBoundaryObserver<T, U extends Collection<? super T>, B> extends QueueDrainObserver<T, U, U> implements Observer<T>, Disposable {
+        final Callable<U> g;
+        final ObservableSource<B> h;
+        Disposable i;
+        Disposable j;
+        U k;
+
+        BufferExactBoundaryObserver(Observer<? super U> observer, Callable<U> callable, ObservableSource<B> observableSource) {
+            super(observer, new MpscLinkedQueue());
+            this.g = callable;
+            this.h = observableSource;
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // io.reactivex.internal.observers.QueueDrainObserver, io.reactivex.internal.util.ObservableQueueDrain
+        public /* bridge */ /* synthetic */ void a(Observer observer, Object obj) {
+            a((Observer<? super Observer>) observer, (Observer) obj);
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            if (this.d) {
+                return;
+            }
+            this.d = true;
+            this.j.dispose();
+            this.i.dispose();
+            if (d()) {
+                this.c.clear();
+            }
+        }
+
+        void f() {
+            try {
+                U call = this.g.call();
+                ObjectHelper.a(call, "The buffer supplied is null");
+                U u = call;
+                synchronized (this) {
+                    U u2 = this.k;
+                    if (u2 == null) {
+                        return;
+                    }
+                    this.k = u;
+                    a(u2, false, this);
+                }
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                dispose();
+                this.b.onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            synchronized (this) {
+                U u = this.k;
+                if (u == null) {
+                    return;
+                }
+                this.k = null;
+                this.c.offer(u);
+                this.e = true;
+                if (d()) {
+                    QueueDrainHelper.a(this.c, this.b, false, this, this);
+                }
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            dispose();
+            this.b.onError(th);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            synchronized (this) {
+                U u = this.k;
+                if (u == null) {
+                    return;
+                }
+                u.add(t);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.i, disposable)) {
+                this.i = disposable;
+                try {
+                    U call = this.g.call();
+                    ObjectHelper.a(call, "The buffer supplied is null");
+                    this.k = call;
+                    BufferBoundaryObserver bufferBoundaryObserver = new BufferBoundaryObserver(this);
+                    this.j = bufferBoundaryObserver;
+                    this.b.onSubscribe(this);
+                    if (this.d) {
+                        return;
+                    }
+                    this.h.subscribe(bufferBoundaryObserver);
+                } catch (Throwable th) {
+                    Exceptions.b(th);
+                    this.d = true;
+                    disposable.dispose();
+                    EmptyDisposable.error(th, this.b);
+                }
+            }
+        }
+
+        public void a(Observer<? super U> observer, U u) {
+            this.b.onNext(u);
+        }
+    }
+
+    public ObservableBufferExactBoundary(ObservableSource<T> observableSource, ObservableSource<B> observableSource2, Callable<U> callable) {
+        super(observableSource);
+        this.b = observableSource2;
+        this.c = callable;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super U> observer) {
+        this.a.subscribe(new BufferExactBoundaryObserver(new SerializedObserver(observer), this.c, this.b));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableBufferTimed.java

@@ -0,0 +1,496 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.Scheduler;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.disposables.EmptyDisposable;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.observers.QueueDrainObserver;
+import io.reactivex.internal.queue.MpscLinkedQueue;
+import io.reactivex.internal.util.QueueDrainHelper;
+import io.reactivex.observers.SerializedObserver;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableBufferTimed<T, U extends Collection<? super T>> extends AbstractObservableWithUpstream<T, U> {
+    final long b;
+    final long c;
+    final TimeUnit d;
+    final Scheduler e;
+    final Callable<U> f;
+    final int g;
+    final boolean h;
+
+    static final class BufferExactBoundedObserver<T, U extends Collection<? super T>> extends QueueDrainObserver<T, U, U> implements Runnable, Disposable {
+        final Callable<U> g;
+        final long h;
+        final TimeUnit i;
+        final int j;
+        final boolean k;
+        final Scheduler.Worker l;
+        U m;
+        Disposable n;
+        Disposable o;
+        long p;
+        long q;
+
+        BufferExactBoundedObserver(Observer<? super U> observer, Callable<U> callable, long j, TimeUnit timeUnit, int i, boolean z, Scheduler.Worker worker) {
+            super(observer, new MpscLinkedQueue());
+            this.g = callable;
+            this.h = j;
+            this.i = timeUnit;
+            this.j = i;
+            this.k = z;
+            this.l = worker;
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // io.reactivex.internal.observers.QueueDrainObserver, io.reactivex.internal.util.ObservableQueueDrain
+        public /* bridge */ /* synthetic */ void a(Observer observer, Object obj) {
+            a((Observer<? super Observer>) observer, (Observer) obj);
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            if (this.d) {
+                return;
+            }
+            this.d = true;
+            this.o.dispose();
+            this.l.dispose();
+            synchronized (this) {
+                this.m = null;
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            U u;
+            this.l.dispose();
+            synchronized (this) {
+                u = this.m;
+                this.m = null;
+            }
+            this.c.offer(u);
+            this.e = true;
+            if (d()) {
+                QueueDrainHelper.a(this.c, this.b, false, this, this);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            synchronized (this) {
+                this.m = null;
+            }
+            this.b.onError(th);
+            this.l.dispose();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            synchronized (this) {
+                U u = this.m;
+                if (u == null) {
+                    return;
+                }
+                u.add(t);
+                if (u.size() < this.j) {
+                    return;
+                }
+                this.m = null;
+                this.p++;
+                if (this.k) {
+                    this.n.dispose();
+                }
+                b(u, false, this);
+                try {
+                    U call = this.g.call();
+                    ObjectHelper.a(call, "The buffer supplied is null");
+                    U u2 = call;
+                    synchronized (this) {
+                        this.m = u2;
+                        this.q++;
+                    }
+                    if (this.k) {
+                        Scheduler.Worker worker = this.l;
+                        long j = this.h;
+                        this.n = worker.a(this, j, j, this.i);
+                    }
+                } catch (Throwable th) {
+                    Exceptions.b(th);
+                    this.b.onError(th);
+                    dispose();
+                }
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.o, disposable)) {
+                this.o = disposable;
+                try {
+                    U call = this.g.call();
+                    ObjectHelper.a(call, "The buffer supplied is null");
+                    this.m = call;
+                    this.b.onSubscribe(this);
+                    Scheduler.Worker worker = this.l;
+                    long j = this.h;
+                    this.n = worker.a(this, j, j, this.i);
+                } catch (Throwable th) {
+                    Exceptions.b(th);
+                    disposable.dispose();
+                    EmptyDisposable.error(th, this.b);
+                    this.l.dispose();
+                }
+            }
+        }
+
+        @Override // java.lang.Runnable
+        public void run() {
+            try {
+                U call = this.g.call();
+                ObjectHelper.a(call, "The bufferSupplier returned a null buffer");
+                U u = call;
+                synchronized (this) {
+                    U u2 = this.m;
+                    if (u2 != null && this.p == this.q) {
+                        this.m = u;
+                        b(u2, false, this);
+                    }
+                }
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                dispose();
+                this.b.onError(th);
+            }
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        public void a(Observer<? super U> observer, U u) {
+            observer.onNext(u);
+        }
+    }
+
+    static final class BufferExactUnboundedObserver<T, U extends Collection<? super T>> extends QueueDrainObserver<T, U, U> implements Runnable, Disposable {
+        final Callable<U> g;
+        final long h;
+        final TimeUnit i;
+        final Scheduler j;
+        Disposable k;
+        U l;
+        final AtomicReference<Disposable> m;
+
+        BufferExactUnboundedObserver(Observer<? super U> observer, Callable<U> callable, long j, TimeUnit timeUnit, Scheduler scheduler) {
+            super(observer, new MpscLinkedQueue());
+            this.m = new AtomicReference<>();
+            this.g = callable;
+            this.h = j;
+            this.i = timeUnit;
+            this.j = scheduler;
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // io.reactivex.internal.observers.QueueDrainObserver, io.reactivex.internal.util.ObservableQueueDrain
+        public /* bridge */ /* synthetic */ void a(Observer observer, Object obj) {
+            a((Observer<? super Observer>) observer, (Observer) obj);
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            DisposableHelper.dispose(this.m);
+            this.k.dispose();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            U u;
+            synchronized (this) {
+                u = this.l;
+                this.l = null;
+            }
+            if (u != null) {
+                this.c.offer(u);
+                this.e = true;
+                if (d()) {
+                    QueueDrainHelper.a(this.c, this.b, false, null, this);
+                }
+            }
+            DisposableHelper.dispose(this.m);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            synchronized (this) {
+                this.l = null;
+            }
+            this.b.onError(th);
+            DisposableHelper.dispose(this.m);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            synchronized (this) {
+                U u = this.l;
+                if (u == null) {
+                    return;
+                }
+                u.add(t);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.k, disposable)) {
+                this.k = disposable;
+                try {
+                    U call = this.g.call();
+                    ObjectHelper.a(call, "The buffer supplied is null");
+                    this.l = call;
+                    this.b.onSubscribe(this);
+                    if (this.d) {
+                        return;
+                    }
+                    Scheduler scheduler = this.j;
+                    long j = this.h;
+                    Disposable a = scheduler.a(this, j, j, this.i);
+                    if (this.m.compareAndSet(null, a)) {
+                        return;
+                    }
+                    a.dispose();
+                } catch (Throwable th) {
+                    Exceptions.b(th);
+                    dispose();
+                    EmptyDisposable.error(th, this.b);
+                }
+            }
+        }
+
+        @Override // java.lang.Runnable
+        public void run() {
+            U u;
+            try {
+                U call = this.g.call();
+                ObjectHelper.a(call, "The bufferSupplier returned a null buffer");
+                U u2 = call;
+                synchronized (this) {
+                    u = this.l;
+                    if (u != null) {
+                        this.l = u2;
+                    }
+                }
+                if (u == null) {
+                    DisposableHelper.dispose(this.m);
+                } else {
+                    a(u, false, this);
+                }
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                this.b.onError(th);
+                dispose();
+            }
+        }
+
+        public void a(Observer<? super U> observer, U u) {
+            this.b.onNext(u);
+        }
+    }
+
+    static final class BufferSkipBoundedObserver<T, U extends Collection<? super T>> extends QueueDrainObserver<T, U, U> implements Runnable, Disposable {
+        final Callable<U> g;
+        final long h;
+        final long i;
+        final TimeUnit j;
+        final Scheduler.Worker k;
+        final List<U> l;
+        Disposable m;
+
+        final class RemoveFromBuffer implements Runnable {
+            private final U a;
+
+            RemoveFromBuffer(U u) {
+                this.a = u;
+            }
+
+            @Override // java.lang.Runnable
+            public void run() {
+                synchronized (BufferSkipBoundedObserver.this) {
+                    BufferSkipBoundedObserver.this.l.remove(this.a);
+                }
+                BufferSkipBoundedObserver bufferSkipBoundedObserver = BufferSkipBoundedObserver.this;
+                bufferSkipBoundedObserver.b(this.a, false, bufferSkipBoundedObserver.k);
+            }
+        }
+
+        final class RemoveFromBufferEmit implements Runnable {
+            private final U a;
+
+            RemoveFromBufferEmit(U u) {
+                this.a = u;
+            }
+
+            @Override // java.lang.Runnable
+            public void run() {
+                synchronized (BufferSkipBoundedObserver.this) {
+                    BufferSkipBoundedObserver.this.l.remove(this.a);
+                }
+                BufferSkipBoundedObserver bufferSkipBoundedObserver = BufferSkipBoundedObserver.this;
+                bufferSkipBoundedObserver.b(this.a, false, bufferSkipBoundedObserver.k);
+            }
+        }
+
+        BufferSkipBoundedObserver(Observer<? super U> observer, Callable<U> callable, long j, long j2, TimeUnit timeUnit, Scheduler.Worker worker) {
+            super(observer, new MpscLinkedQueue());
+            this.g = callable;
+            this.h = j;
+            this.i = j2;
+            this.j = timeUnit;
+            this.k = worker;
+            this.l = new LinkedList();
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // io.reactivex.internal.observers.QueueDrainObserver, io.reactivex.internal.util.ObservableQueueDrain
+        public /* bridge */ /* synthetic */ void a(Observer observer, Object obj) {
+            a((Observer<? super Observer>) observer, (Observer) obj);
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            if (this.d) {
+                return;
+            }
+            this.d = true;
+            f();
+            this.m.dispose();
+            this.k.dispose();
+        }
+
+        void f() {
+            synchronized (this) {
+                this.l.clear();
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            ArrayList arrayList;
+            synchronized (this) {
+                arrayList = new ArrayList(this.l);
+                this.l.clear();
+            }
+            Iterator it = arrayList.iterator();
+            while (it.hasNext()) {
+                this.c.offer((Collection) it.next());
+            }
+            this.e = true;
+            if (d()) {
+                QueueDrainHelper.a(this.c, this.b, false, this.k, this);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            this.e = true;
+            f();
+            this.b.onError(th);
+            this.k.dispose();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            synchronized (this) {
+                Iterator<U> it = this.l.iterator();
+                while (it.hasNext()) {
+                    it.next().add(t);
+                }
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.m, disposable)) {
+                this.m = disposable;
+                try {
+                    U call = this.g.call();
+                    ObjectHelper.a(call, "The buffer supplied is null");
+                    U u = call;
+                    this.l.add(u);
+                    this.b.onSubscribe(this);
+                    Scheduler.Worker worker = this.k;
+                    long j = this.i;
+                    worker.a(this, j, j, this.j);
+                    this.k.a(new RemoveFromBufferEmit(u), this.h, this.j);
+                } catch (Throwable th) {
+                    Exceptions.b(th);
+                    disposable.dispose();
+                    EmptyDisposable.error(th, this.b);
+                    this.k.dispose();
+                }
+            }
+        }
+
+        @Override // java.lang.Runnable
+        public void run() {
+            if (this.d) {
+                return;
+            }
+            try {
+                U call = this.g.call();
+                ObjectHelper.a(call, "The bufferSupplier returned a null buffer");
+                U u = call;
+                synchronized (this) {
+                    if (this.d) {
+                        return;
+                    }
+                    this.l.add(u);
+                    this.k.a(new RemoveFromBuffer(u), this.h, this.j);
+                }
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                this.b.onError(th);
+                dispose();
+            }
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        public void a(Observer<? super U> observer, U u) {
+            observer.onNext(u);
+        }
+    }
+
+    public ObservableBufferTimed(ObservableSource<T> observableSource, long j, long j2, TimeUnit timeUnit, Scheduler scheduler, Callable<U> callable, int i, boolean z) {
+        super(observableSource);
+        this.b = j;
+        this.c = j2;
+        this.d = timeUnit;
+        this.e = scheduler;
+        this.f = callable;
+        this.g = i;
+        this.h = z;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super U> observer) {
+        if (this.b == this.c && this.g == Integer.MAX_VALUE) {
+            this.a.subscribe(new BufferExactUnboundedObserver(new SerializedObserver(observer), this.f, this.b, this.d, this.e));
+            return;
+        }
+        Scheduler.Worker a = this.e.a();
+        if (this.b == this.c) {
+            this.a.subscribe(new BufferExactBoundedObserver(new SerializedObserver(observer), this.f, this.b, this.d, this.g, this.h, a));
+        } else {
+            this.a.subscribe(new BufferSkipBoundedObserver(new SerializedObserver(observer), this.f, this.b, this.c, this.d, a));
+        }
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableCache.java

@@ -0,0 +1,226 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.SequentialDisposable;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.util.LinkedArrayList;
+import io.reactivex.internal.util.NotificationLite;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableCache<T> extends AbstractObservableWithUpstream<T, T> {
+    final CacheState<T> b;
+    final AtomicBoolean c;
+
+    static final class CacheState<T> extends LinkedArrayList implements Observer<T> {
+        static final ReplayDisposable[] j = new ReplayDisposable[0];
+        static final ReplayDisposable[] k = new ReplayDisposable[0];
+        final Observable<? extends T> f;
+        final SequentialDisposable g;
+        final AtomicReference<ReplayDisposable<T>[]> h;
+        boolean i;
+
+        CacheState(Observable<? extends T> observable, int i) {
+            super(i);
+            this.f = observable;
+            this.h = new AtomicReference<>(j);
+            this.g = new SequentialDisposable();
+        }
+
+        public boolean a(ReplayDisposable<T> replayDisposable) {
+            ReplayDisposable<T>[] replayDisposableArr;
+            ReplayDisposable<T>[] replayDisposableArr2;
+            do {
+                replayDisposableArr = this.h.get();
+                if (replayDisposableArr == k) {
+                    return false;
+                }
+                int length = replayDisposableArr.length;
+                replayDisposableArr2 = new ReplayDisposable[length + 1];
+                System.arraycopy(replayDisposableArr, 0, replayDisposableArr2, 0, length);
+                replayDisposableArr2[length] = replayDisposable;
+            } while (!this.h.compareAndSet(replayDisposableArr, replayDisposableArr2));
+            return true;
+        }
+
+        public void b(ReplayDisposable<T> replayDisposable) {
+            ReplayDisposable<T>[] replayDisposableArr;
+            ReplayDisposable<T>[] replayDisposableArr2;
+            do {
+                replayDisposableArr = this.h.get();
+                int length = replayDisposableArr.length;
+                if (length == 0) {
+                    return;
+                }
+                int i = -1;
+                int i2 = 0;
+                while (true) {
+                    if (i2 >= length) {
+                        break;
+                    }
+                    if (replayDisposableArr[i2].equals(replayDisposable)) {
+                        i = i2;
+                        break;
+                    }
+                    i2++;
+                }
+                if (i < 0) {
+                    return;
+                }
+                if (length == 1) {
+                    replayDisposableArr2 = j;
+                } else {
+                    ReplayDisposable<T>[] replayDisposableArr3 = new ReplayDisposable[length - 1];
+                    System.arraycopy(replayDisposableArr, 0, replayDisposableArr3, 0, i);
+                    System.arraycopy(replayDisposableArr, i + 1, replayDisposableArr3, i, (length - i) - 1);
+                    replayDisposableArr2 = replayDisposableArr3;
+                }
+            } while (!this.h.compareAndSet(replayDisposableArr, replayDisposableArr2));
+        }
+
+        public void c() {
+            this.f.subscribe(this);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            if (this.i) {
+                return;
+            }
+            this.i = true;
+            a(NotificationLite.complete());
+            this.g.dispose();
+            for (ReplayDisposable<T> replayDisposable : this.h.getAndSet(k)) {
+                replayDisposable.a();
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (this.i) {
+                return;
+            }
+            this.i = true;
+            a(NotificationLite.error(th));
+            this.g.dispose();
+            for (ReplayDisposable<T> replayDisposable : this.h.getAndSet(k)) {
+                replayDisposable.a();
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            if (this.i) {
+                return;
+            }
+            a(NotificationLite.next(t));
+            for (ReplayDisposable<T> replayDisposable : this.h.get()) {
+                replayDisposable.a();
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            this.g.update(disposable);
+        }
+    }
+
+    static final class ReplayDisposable<T> extends AtomicInteger implements Disposable {
+        final Observer<? super T> a;
+        final CacheState<T> b;
+        Object[] c;
+        int d;
+        int e;
+        volatile boolean f;
+
+        ReplayDisposable(Observer<? super T> observer, CacheState<T> cacheState) {
+            this.a = observer;
+            this.b = cacheState;
+        }
+
+        public void a() {
+            if (getAndIncrement() != 0) {
+                return;
+            }
+            Observer<? super T> observer = this.a;
+            int i = 1;
+            while (!this.f) {
+                int b = this.b.b();
+                if (b != 0) {
+                    Object[] objArr = this.c;
+                    if (objArr == null) {
+                        objArr = this.b.a();
+                        this.c = objArr;
+                    }
+                    int length = objArr.length - 1;
+                    int i2 = this.e;
+                    int i3 = this.d;
+                    while (i2 < b) {
+                        if (this.f) {
+                            return;
+                        }
+                        if (i3 == length) {
+                            objArr = (Object[]) objArr[length];
+                            i3 = 0;
+                        }
+                        if (NotificationLite.accept(objArr[i3], observer)) {
+                            return;
+                        }
+                        i3++;
+                        i2++;
+                    }
+                    if (this.f) {
+                        return;
+                    }
+                    this.e = i2;
+                    this.d = i3;
+                    this.c = objArr;
+                }
+                i = addAndGet(-i);
+                if (i == 0) {
+                    return;
+                }
+            }
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            if (this.f) {
+                return;
+            }
+            this.f = true;
+            this.b.b(this);
+        }
+    }
+
+    private ObservableCache(Observable<T> observable, CacheState<T> cacheState) {
+        super(observable);
+        this.b = cacheState;
+        this.c = new AtomicBoolean();
+    }
+
+    public static <T> Observable<T> a(Observable<T> observable) {
+        return a(observable, 16);
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super T> observer) {
+        ReplayDisposable<T> replayDisposable = new ReplayDisposable<>(observer, this.b);
+        observer.onSubscribe(replayDisposable);
+        this.b.a((ReplayDisposable) replayDisposable);
+        if (!this.c.get() && this.c.compareAndSet(false, true)) {
+            this.b.c();
+        }
+        replayDisposable.a();
+    }
+
+    public static <T> Observable<T> a(Observable<T> observable, int i) {
+        ObjectHelper.a(i, "capacityHint");
+        return RxJavaPlugins.a(new ObservableCache(observable, new CacheState(observable, i)));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableCollect.java

@@ -0,0 +1,94 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.functions.BiConsumer;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.disposables.EmptyDisposable;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.Callable;
+
+/* loaded from: classes2.dex */
+public final class ObservableCollect<T, U> extends AbstractObservableWithUpstream<T, U> {
+    final Callable<? extends U> b;
+    final BiConsumer<? super U, ? super T> c;
+
+    static final class CollectObserver<T, U> implements Observer<T>, Disposable {
+        final Observer<? super U> a;
+        final BiConsumer<? super U, ? super T> b;
+        final U c;
+        Disposable d;
+        boolean e;
+
+        CollectObserver(Observer<? super U> observer, U u, BiConsumer<? super U, ? super T> biConsumer) {
+            this.a = observer;
+            this.b = biConsumer;
+            this.c = u;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.d.dispose();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            if (this.e) {
+                return;
+            }
+            this.e = true;
+            this.a.onNext(this.c);
+            this.a.onComplete();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (this.e) {
+                RxJavaPlugins.b(th);
+            } else {
+                this.e = true;
+                this.a.onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            if (this.e) {
+                return;
+            }
+            try {
+                this.b.a(this.c, t);
+            } catch (Throwable th) {
+                this.d.dispose();
+                onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.d, disposable)) {
+                this.d = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+    }
+
+    public ObservableCollect(ObservableSource<T> observableSource, Callable<? extends U> callable, BiConsumer<? super U, ? super T> biConsumer) {
+        super(observableSource);
+        this.b = callable;
+        this.c = biConsumer;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super U> observer) {
+        try {
+            U call = this.b.call();
+            ObjectHelper.a(call, "The initialSupplier returned a null value");
+            this.a.subscribe(new CollectObserver(observer, call, this.c));
+        } catch (Throwable th) {
+            EmptyDisposable.error(th, observer);
+        }
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableCollectSingle.java

@@ -0,0 +1,103 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Observable;
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.Single;
+import io.reactivex.SingleObserver;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.functions.BiConsumer;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.disposables.EmptyDisposable;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.fuseable.FuseToObservable;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.Callable;
+
+/* loaded from: classes2.dex */
+public final class ObservableCollectSingle<T, U> extends Single<U> implements FuseToObservable<U> {
+    final ObservableSource<T> a;
+    final Callable<? extends U> b;
+    final BiConsumer<? super U, ? super T> c;
+
+    static final class CollectObserver<T, U> implements Observer<T>, Disposable {
+        final SingleObserver<? super U> a;
+        final BiConsumer<? super U, ? super T> b;
+        final U c;
+        Disposable d;
+        boolean e;
+
+        CollectObserver(SingleObserver<? super U> singleObserver, U u, BiConsumer<? super U, ? super T> biConsumer) {
+            this.a = singleObserver;
+            this.b = biConsumer;
+            this.c = u;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.d.dispose();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            if (this.e) {
+                return;
+            }
+            this.e = true;
+            this.a.onSuccess(this.c);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (this.e) {
+                RxJavaPlugins.b(th);
+            } else {
+                this.e = true;
+                this.a.onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            if (this.e) {
+                return;
+            }
+            try {
+                this.b.a(this.c, t);
+            } catch (Throwable th) {
+                this.d.dispose();
+                onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.d, disposable)) {
+                this.d = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+    }
+
+    public ObservableCollectSingle(ObservableSource<T> observableSource, Callable<? extends U> callable, BiConsumer<? super U, ? super T> biConsumer) {
+        this.a = observableSource;
+        this.b = callable;
+        this.c = biConsumer;
+    }
+
+    @Override // io.reactivex.internal.fuseable.FuseToObservable
+    public Observable<U> a() {
+        return RxJavaPlugins.a(new ObservableCollect(this.a, this.b, this.c));
+    }
+
+    @Override // io.reactivex.Single
+    protected void b(SingleObserver<? super U> singleObserver) {
+        try {
+            U call = this.b.call();
+            ObjectHelper.a(call, "The initialSupplier returned a null value");
+            this.a.subscribe(new CollectObserver(singleObserver, call, this.c));
+        } catch (Throwable th) {
+            EmptyDisposable.error(th, singleObserver);
+        }
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableCombineLatest.java

@@ -0,0 +1,342 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Observable;
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Function;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.disposables.EmptyDisposable;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.queue.SpscLinkedArrayQueue;
+import io.reactivex.internal.util.AtomicThrowable;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableCombineLatest<T, R> extends Observable<R> {
+    final ObservableSource<? extends T>[] a;
+    final Iterable<? extends ObservableSource<? extends T>> b;
+    final Function<? super Object[], ? extends R> c;
+    final int d;
+    final boolean e;
+
+    static final class CombinerObserver<T, R> extends AtomicReference<Disposable> implements Observer<T> {
+        final LatestCoordinator<T, R> a;
+        final int b;
+
+        CombinerObserver(LatestCoordinator<T, R> latestCoordinator, int i) {
+            this.a = latestCoordinator;
+            this.b = i;
+        }
+
+        public void a() {
+            DisposableHelper.dispose(this);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.a.a(this.b);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            this.a.a(this.b, th);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            this.a.a(this.b, (int) t);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            DisposableHelper.setOnce(this, disposable);
+        }
+    }
+
+    public ObservableCombineLatest(ObservableSource<? extends T>[] observableSourceArr, Iterable<? extends ObservableSource<? extends T>> iterable, Function<? super Object[], ? extends R> function, int i, boolean z) {
+        this.a = observableSourceArr;
+        this.b = iterable;
+        this.c = function;
+        this.d = i;
+        this.e = z;
+    }
+
+    @Override // io.reactivex.Observable
+    public void subscribeActual(Observer<? super R> observer) {
+        int length;
+        ObservableSource<? extends T>[] observableSourceArr = this.a;
+        if (observableSourceArr == null) {
+            observableSourceArr = new Observable[8];
+            length = 0;
+            for (ObservableSource<? extends T> observableSource : this.b) {
+                if (length == observableSourceArr.length) {
+                    ObservableSource<? extends T>[] observableSourceArr2 = new ObservableSource[(length >> 2) + length];
+                    System.arraycopy(observableSourceArr, 0, observableSourceArr2, 0, length);
+                    observableSourceArr = observableSourceArr2;
+                }
+                observableSourceArr[length] = observableSource;
+                length++;
+            }
+        } else {
+            length = observableSourceArr.length;
+        }
+        int i = length;
+        if (i == 0) {
+            EmptyDisposable.complete(observer);
+        } else {
+            new LatestCoordinator(observer, this.c, i, this.d, this.e).a(observableSourceArr);
+        }
+    }
+
+    static final class LatestCoordinator<T, R> extends AtomicInteger implements Disposable {
+        final Observer<? super R> a;
+        final Function<? super Object[], ? extends R> b;
+        final CombinerObserver<T, R>[] c;
+        Object[] d;
+        final SpscLinkedArrayQueue<Object[]> e;
+        final boolean f;
+        volatile boolean g;
+        volatile boolean h;
+        final AtomicThrowable i = new AtomicThrowable();
+        int j;
+        int k;
+
+        LatestCoordinator(Observer<? super R> observer, Function<? super Object[], ? extends R> function, int i, int i2, boolean z) {
+            this.a = observer;
+            this.b = function;
+            this.f = z;
+            this.d = new Object[i];
+            CombinerObserver<T, R>[] combinerObserverArr = new CombinerObserver[i];
+            for (int i3 = 0; i3 < i; i3++) {
+                combinerObserverArr[i3] = new CombinerObserver<>(this, i3);
+            }
+            this.c = combinerObserverArr;
+            this.e = new SpscLinkedArrayQueue<>(i2);
+        }
+
+        public void a(ObservableSource<? extends T>[] observableSourceArr) {
+            CombinerObserver<T, R>[] combinerObserverArr = this.c;
+            int length = combinerObserverArr.length;
+            this.a.onSubscribe(this);
+            for (int i = 0; i < length && !this.h && !this.g; i++) {
+                observableSourceArr[i].subscribe(combinerObserverArr[i]);
+            }
+        }
+
+        void b() {
+            if (getAndIncrement() != 0) {
+                return;
+            }
+            SpscLinkedArrayQueue<Object[]> spscLinkedArrayQueue = this.e;
+            Observer<? super R> observer = this.a;
+            boolean z = this.f;
+            int i = 1;
+            while (!this.g) {
+                if (!z && this.i.get() != null) {
+                    a();
+                    a((SpscLinkedArrayQueue<?>) spscLinkedArrayQueue);
+                    observer.onError(this.i.terminate());
+                    return;
+                }
+                boolean z2 = this.h;
+                Object[] poll = spscLinkedArrayQueue.poll();
+                boolean z3 = poll == null;
+                if (z2 && z3) {
+                    a((SpscLinkedArrayQueue<?>) spscLinkedArrayQueue);
+                    Throwable terminate = this.i.terminate();
+                    if (terminate == null) {
+                        observer.onComplete();
+                        return;
+                    } else {
+                        observer.onError(terminate);
+                        return;
+                    }
+                }
+                if (z3) {
+                    i = addAndGet(-i);
+                    if (i == 0) {
+                        return;
+                    }
+                } else {
+                    try {
+                        R apply = this.b.apply(poll);
+                        ObjectHelper.a(apply, "The combiner returned a null value");
+                        observer.onNext(apply);
+                    } catch (Throwable th) {
+                        Exceptions.b(th);
+                        this.i.addThrowable(th);
+                        a();
+                        a((SpscLinkedArrayQueue<?>) spscLinkedArrayQueue);
+                        observer.onError(this.i.terminate());
+                        return;
+                    }
+                }
+            }
+            a((SpscLinkedArrayQueue<?>) spscLinkedArrayQueue);
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            if (this.g) {
+                return;
+            }
+            this.g = true;
+            a();
+            if (getAndIncrement() == 0) {
+                a((SpscLinkedArrayQueue<?>) this.e);
+            }
+        }
+
+        void a() {
+            for (CombinerObserver<T, R> combinerObserver : this.c) {
+                combinerObserver.a();
+            }
+        }
+
+        void a(SpscLinkedArrayQueue<?> spscLinkedArrayQueue) {
+            synchronized (this) {
+                this.d = null;
+            }
+            spscLinkedArrayQueue.clear();
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        void a(int i, T t) {
+            boolean z;
+            synchronized (this) {
+                Object[] objArr = this.d;
+                if (objArr == null) {
+                    return;
+                }
+                Object obj = objArr[i];
+                int i2 = this.j;
+                if (obj == null) {
+                    i2++;
+                    this.j = i2;
+                }
+                objArr[i] = t;
+                if (i2 == objArr.length) {
+                    this.e.offer(objArr.clone());
+                    z = true;
+                } else {
+                    z = false;
+                }
+                if (z) {
+                    b();
+                }
+            }
+        }
+
+        /* JADX WARN: Code restructure failed: missing block: B:17:0x0023, code lost:
+        
+            if (r1 == r4.length) goto L18;
+         */
+        /*
+            Code decompiled incorrectly, please refer to instructions dump.
+            To view partially-correct code enable 'Show inconsistent code' option in preferences
+        */
+        void a(int r3, java.lang.Throwable r4) {
+            /*
+                r2 = this;
+                io.reactivex.internal.util.AtomicThrowable r0 = r2.i
+                boolean r0 = r0.addThrowable(r4)
+                if (r0 == 0) goto L36
+                boolean r4 = r2.f
+                r0 = 1
+                if (r4 == 0) goto L2c
+                monitor-enter(r2)
+                java.lang.Object[] r4 = r2.d     // Catch: java.lang.Throwable -> L29
+                if (r4 != 0) goto L14
+                monitor-exit(r2)     // Catch: java.lang.Throwable -> L29
+                return
+            L14:
+                r3 = r4[r3]     // Catch: java.lang.Throwable -> L29
+                if (r3 != 0) goto L1a
+                r3 = 1
+                goto L1b
+            L1a:
+                r3 = 0
+            L1b:
+                if (r3 != 0) goto L25
+                int r1 = r2.k     // Catch: java.lang.Throwable -> L29
+                int r1 = r1 + r0
+                r2.k = r1     // Catch: java.lang.Throwable -> L29
+                int r4 = r4.length     // Catch: java.lang.Throwable -> L29
+                if (r1 != r4) goto L27
+            L25:
+                r2.h = r0     // Catch: java.lang.Throwable -> L29
+            L27:
+                monitor-exit(r2)     // Catch: java.lang.Throwable -> L29
+                goto L2d
+            L29:
+                r3 = move-exception
+                monitor-exit(r2)     // Catch: java.lang.Throwable -> L29
+                throw r3
+            L2c:
+                r3 = 1
+            L2d:
+                if (r3 == 0) goto L32
+                r2.a()
+            L32:
+                r2.b()
+                goto L39
+            L36:
+                io.reactivex.plugins.RxJavaPlugins.b(r4)
+            L39:
+                return
+            */
+            throw new UnsupportedOperationException("Method not decompiled: io.reactivex.internal.operators.observable.ObservableCombineLatest.LatestCoordinator.a(int, java.lang.Throwable):void");
+        }
+
+        /* JADX WARN: Code restructure failed: missing block: B:13:0x0017, code lost:
+        
+            if (r2 == r0.length) goto L14;
+         */
+        /*
+            Code decompiled incorrectly, please refer to instructions dump.
+            To view partially-correct code enable 'Show inconsistent code' option in preferences
+        */
+        void a(int r4) {
+            /*
+                r3 = this;
+                monitor-enter(r3)
+                java.lang.Object[] r0 = r3.d     // Catch: java.lang.Throwable -> L25
+                if (r0 != 0) goto L7
+                monitor-exit(r3)     // Catch: java.lang.Throwable -> L25
+                return
+            L7:
+                r4 = r0[r4]     // Catch: java.lang.Throwable -> L25
+                r1 = 1
+                if (r4 != 0) goto Le
+                r4 = 1
+                goto Lf
+            Le:
+                r4 = 0
+            Lf:
+                if (r4 != 0) goto L19
+                int r2 = r3.k     // Catch: java.lang.Throwable -> L25
+                int r2 = r2 + r1
+                r3.k = r2     // Catch: java.lang.Throwable -> L25
+                int r0 = r0.length     // Catch: java.lang.Throwable -> L25
+                if (r2 != r0) goto L1b
+            L19:
+                r3.h = r1     // Catch: java.lang.Throwable -> L25
+            L1b:
+                monitor-exit(r3)     // Catch: java.lang.Throwable -> L25
+                if (r4 == 0) goto L21
+                r3.a()
+            L21:
+                r3.b()
+                return
+            L25:
+                r4 = move-exception
+                monitor-exit(r3)     // Catch: java.lang.Throwable -> L25
+                throw r4
+            */
+            throw new UnsupportedOperationException("Method not decompiled: io.reactivex.internal.operators.observable.ObservableCombineLatest.LatestCoordinator.a(int):void");
+        }
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableConcatMap.java

@@ -0,0 +1,424 @@
+package io.reactivex.internal.operators.observable;
+
+import android.Manifest;
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Function;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.fuseable.QueueDisposable;
+import io.reactivex.internal.fuseable.SimpleQueue;
+import io.reactivex.internal.queue.SpscLinkedArrayQueue;
+import io.reactivex.internal.util.AtomicThrowable;
+import io.reactivex.internal.util.ErrorMode;
+import io.reactivex.observers.SerializedObserver;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.Callable;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableConcatMap<T, U> extends AbstractObservableWithUpstream<T, U> {
+    final Function<? super T, ? extends ObservableSource<? extends U>> b;
+    final int c;
+    final ErrorMode d;
+
+    static final class ConcatMapDelayErrorObserver<T, R> extends AtomicInteger implements Observer<T>, Disposable {
+        final Observer<? super R> a;
+        final Function<? super T, ? extends ObservableSource<? extends R>> b;
+        final int c;
+        final AtomicThrowable d = new AtomicThrowable();
+        final DelayErrorInnerObserver<R> e;
+        final boolean f;
+        SimpleQueue<T> g;
+        Disposable h;
+        volatile boolean i;
+        volatile boolean j;
+        volatile boolean k;
+        int l;
+
+        static final class DelayErrorInnerObserver<R> extends AtomicReference<Disposable> implements Observer<R> {
+            final Observer<? super R> a;
+            final ConcatMapDelayErrorObserver<?, R> b;
+
+            DelayErrorInnerObserver(Observer<? super R> observer, ConcatMapDelayErrorObserver<?, R> concatMapDelayErrorObserver) {
+                this.a = observer;
+                this.b = concatMapDelayErrorObserver;
+            }
+
+            void a() {
+                DisposableHelper.dispose(this);
+            }
+
+            @Override // io.reactivex.Observer
+            public void onComplete() {
+                ConcatMapDelayErrorObserver<?, R> concatMapDelayErrorObserver = this.b;
+                concatMapDelayErrorObserver.i = false;
+                concatMapDelayErrorObserver.a();
+            }
+
+            @Override // io.reactivex.Observer
+            public void onError(Throwable th) {
+                ConcatMapDelayErrorObserver<?, R> concatMapDelayErrorObserver = this.b;
+                if (!concatMapDelayErrorObserver.d.addThrowable(th)) {
+                    RxJavaPlugins.b(th);
+                    return;
+                }
+                if (!concatMapDelayErrorObserver.f) {
+                    concatMapDelayErrorObserver.h.dispose();
+                }
+                concatMapDelayErrorObserver.i = false;
+                concatMapDelayErrorObserver.a();
+            }
+
+            @Override // io.reactivex.Observer
+            public void onNext(R r) {
+                this.a.onNext(r);
+            }
+
+            @Override // io.reactivex.Observer
+            public void onSubscribe(Disposable disposable) {
+                DisposableHelper.replace(this, disposable);
+            }
+        }
+
+        ConcatMapDelayErrorObserver(Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> function, int i, boolean z) {
+            this.a = observer;
+            this.b = function;
+            this.c = i;
+            this.f = z;
+            this.e = new DelayErrorInnerObserver<>(observer, this);
+        }
+
+        void a() {
+            if (getAndIncrement() != 0) {
+                return;
+            }
+            Observer<? super R> observer = this.a;
+            SimpleQueue<T> simpleQueue = this.g;
+            AtomicThrowable atomicThrowable = this.d;
+            while (true) {
+                if (!this.i) {
+                    if (this.k) {
+                        simpleQueue.clear();
+                        return;
+                    }
+                    if (!this.f && atomicThrowable.get() != null) {
+                        simpleQueue.clear();
+                        this.k = true;
+                        observer.onError(atomicThrowable.terminate());
+                        return;
+                    }
+                    boolean z = this.j;
+                    try {
+                        T poll = simpleQueue.poll();
+                        boolean z2 = poll == null;
+                        if (z && z2) {
+                            this.k = true;
+                            Throwable terminate = atomicThrowable.terminate();
+                            if (terminate != null) {
+                                observer.onError(terminate);
+                                return;
+                            } else {
+                                observer.onComplete();
+                                return;
+                            }
+                        }
+                        if (!z2) {
+                            try {
+                                ObservableSource<? extends R> apply = this.b.apply(poll);
+                                ObjectHelper.a(apply, "The mapper returned a null ObservableSource");
+                                ObservableSource<? extends R> observableSource = apply;
+                                if (observableSource instanceof Callable) {
+                                    try {
+                                        Manifest manifest = (Object) ((Callable) observableSource).call();
+                                        if (manifest != null && !this.k) {
+                                            observer.onNext(manifest);
+                                        }
+                                    } catch (Throwable th) {
+                                        Exceptions.b(th);
+                                        atomicThrowable.addThrowable(th);
+                                    }
+                                } else {
+                                    this.i = true;
+                                    observableSource.subscribe(this.e);
+                                }
+                            } catch (Throwable th2) {
+                                Exceptions.b(th2);
+                                this.k = true;
+                                this.h.dispose();
+                                simpleQueue.clear();
+                                atomicThrowable.addThrowable(th2);
+                                observer.onError(atomicThrowable.terminate());
+                                return;
+                            }
+                        }
+                    } catch (Throwable th3) {
+                        Exceptions.b(th3);
+                        this.k = true;
+                        this.h.dispose();
+                        atomicThrowable.addThrowable(th3);
+                        observer.onError(atomicThrowable.terminate());
+                        return;
+                    }
+                }
+                if (decrementAndGet() == 0) {
+                    return;
+                }
+            }
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.k = true;
+            this.h.dispose();
+            this.e.a();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.j = true;
+            a();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (!this.d.addThrowable(th)) {
+                RxJavaPlugins.b(th);
+            } else {
+                this.j = true;
+                a();
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            if (this.l == 0) {
+                this.g.offer(t);
+            }
+            a();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.h, disposable)) {
+                this.h = disposable;
+                if (disposable instanceof QueueDisposable) {
+                    QueueDisposable queueDisposable = (QueueDisposable) disposable;
+                    int requestFusion = queueDisposable.requestFusion(3);
+                    if (requestFusion == 1) {
+                        this.l = requestFusion;
+                        this.g = queueDisposable;
+                        this.j = true;
+                        this.a.onSubscribe(this);
+                        a();
+                        return;
+                    }
+                    if (requestFusion == 2) {
+                        this.l = requestFusion;
+                        this.g = queueDisposable;
+                        this.a.onSubscribe(this);
+                        return;
+                    }
+                }
+                this.g = new SpscLinkedArrayQueue(this.c);
+                this.a.onSubscribe(this);
+            }
+        }
+    }
+
+    static final class SourceObserver<T, U> extends AtomicInteger implements Observer<T>, Disposable {
+        final Observer<? super U> a;
+        final Function<? super T, ? extends ObservableSource<? extends U>> b;
+        final InnerObserver<U> c;
+        final int d;
+        SimpleQueue<T> e;
+        Disposable f;
+        volatile boolean g;
+        volatile boolean h;
+        volatile boolean i;
+        int j;
+
+        static final class InnerObserver<U> extends AtomicReference<Disposable> implements Observer<U> {
+            final Observer<? super U> a;
+            final SourceObserver<?, ?> b;
+
+            InnerObserver(Observer<? super U> observer, SourceObserver<?, ?> sourceObserver) {
+                this.a = observer;
+                this.b = sourceObserver;
+            }
+
+            void a() {
+                DisposableHelper.dispose(this);
+            }
+
+            @Override // io.reactivex.Observer
+            public void onComplete() {
+                this.b.b();
+            }
+
+            @Override // io.reactivex.Observer
+            public void onError(Throwable th) {
+                this.b.dispose();
+                this.a.onError(th);
+            }
+
+            @Override // io.reactivex.Observer
+            public void onNext(U u) {
+                this.a.onNext(u);
+            }
+
+            @Override // io.reactivex.Observer
+            public void onSubscribe(Disposable disposable) {
+                DisposableHelper.set(this, disposable);
+            }
+        }
+
+        SourceObserver(Observer<? super U> observer, Function<? super T, ? extends ObservableSource<? extends U>> function, int i) {
+            this.a = observer;
+            this.b = function;
+            this.d = i;
+            this.c = new InnerObserver<>(observer, this);
+        }
+
+        void a() {
+            if (getAndIncrement() != 0) {
+                return;
+            }
+            while (!this.h) {
+                if (!this.g) {
+                    boolean z = this.i;
+                    try {
+                        T poll = this.e.poll();
+                        boolean z2 = poll == null;
+                        if (z && z2) {
+                            this.h = true;
+                            this.a.onComplete();
+                            return;
+                        }
+                        if (!z2) {
+                            try {
+                                ObservableSource<? extends U> apply = this.b.apply(poll);
+                                ObjectHelper.a(apply, "The mapper returned a null ObservableSource");
+                                ObservableSource<? extends U> observableSource = apply;
+                                this.g = true;
+                                observableSource.subscribe(this.c);
+                            } catch (Throwable th) {
+                                Exceptions.b(th);
+                                dispose();
+                                this.e.clear();
+                                this.a.onError(th);
+                                return;
+                            }
+                        }
+                    } catch (Throwable th2) {
+                        Exceptions.b(th2);
+                        dispose();
+                        this.e.clear();
+                        this.a.onError(th2);
+                        return;
+                    }
+                }
+                if (decrementAndGet() == 0) {
+                    return;
+                }
+            }
+            this.e.clear();
+        }
+
+        void b() {
+            this.g = false;
+            a();
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.h = true;
+            this.c.a();
+            this.f.dispose();
+            if (getAndIncrement() == 0) {
+                this.e.clear();
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            if (this.i) {
+                return;
+            }
+            this.i = true;
+            a();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (this.i) {
+                RxJavaPlugins.b(th);
+                return;
+            }
+            this.i = true;
+            dispose();
+            this.a.onError(th);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            if (this.i) {
+                return;
+            }
+            if (this.j == 0) {
+                this.e.offer(t);
+            }
+            a();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.f, disposable)) {
+                this.f = disposable;
+                if (disposable instanceof QueueDisposable) {
+                    QueueDisposable queueDisposable = (QueueDisposable) disposable;
+                    int requestFusion = queueDisposable.requestFusion(3);
+                    if (requestFusion == 1) {
+                        this.j = requestFusion;
+                        this.e = queueDisposable;
+                        this.i = true;
+                        this.a.onSubscribe(this);
+                        a();
+                        return;
+                    }
+                    if (requestFusion == 2) {
+                        this.j = requestFusion;
+                        this.e = queueDisposable;
+                        this.a.onSubscribe(this);
+                        return;
+                    }
+                }
+                this.e = new SpscLinkedArrayQueue(this.d);
+                this.a.onSubscribe(this);
+            }
+        }
+    }
+
+    public ObservableConcatMap(ObservableSource<T> observableSource, Function<? super T, ? extends ObservableSource<? extends U>> function, int i, ErrorMode errorMode) {
+        super(observableSource);
+        this.b = function;
+        this.d = errorMode;
+        this.c = Math.max(8, i);
+    }
+
+    @Override // io.reactivex.Observable
+    public void subscribeActual(Observer<? super U> observer) {
+        if (ObservableScalarXMap.a(this.a, observer, this.b)) {
+            return;
+        }
+        ErrorMode errorMode = this.d;
+        if (errorMode == ErrorMode.IMMEDIATE) {
+            this.a.subscribe(new SourceObserver(new SerializedObserver(observer), this.b, this.c));
+        } else {
+            this.a.subscribe(new ConcatMapDelayErrorObserver(observer, this.b, this.c, errorMode == ErrorMode.END));
+        }
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableConcatMapEager.java

@@ -0,0 +1,288 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Function;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.fuseable.QueueDisposable;
+import io.reactivex.internal.fuseable.SimpleQueue;
+import io.reactivex.internal.observers.InnerQueuedObserver;
+import io.reactivex.internal.observers.InnerQueuedObserverSupport;
+import io.reactivex.internal.queue.SpscLinkedArrayQueue;
+import io.reactivex.internal.util.AtomicThrowable;
+import io.reactivex.internal.util.ErrorMode;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.ArrayDeque;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/* loaded from: classes2.dex */
+public final class ObservableConcatMapEager<T, R> extends AbstractObservableWithUpstream<T, R> {
+    final Function<? super T, ? extends ObservableSource<? extends R>> b;
+    final ErrorMode c;
+    final int d;
+    final int e;
+
+    public ObservableConcatMapEager(ObservableSource<T> observableSource, Function<? super T, ? extends ObservableSource<? extends R>> function, ErrorMode errorMode, int i, int i2) {
+        super(observableSource);
+        this.b = function;
+        this.c = errorMode;
+        this.d = i;
+        this.e = i2;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super R> observer) {
+        this.a.subscribe(new ConcatMapEagerMainObserver(observer, this.b, this.d, this.e, this.c));
+    }
+
+    static final class ConcatMapEagerMainObserver<T, R> extends AtomicInteger implements Observer<T>, Disposable, InnerQueuedObserverSupport<R> {
+        final Observer<? super R> a;
+        final Function<? super T, ? extends ObservableSource<? extends R>> b;
+        final int c;
+        final int d;
+        final ErrorMode e;
+        final AtomicThrowable f = new AtomicThrowable();
+        final ArrayDeque<InnerQueuedObserver<R>> g = new ArrayDeque<>();
+        SimpleQueue<T> h;
+        Disposable i;
+        volatile boolean j;
+        int k;
+        volatile boolean l;
+        InnerQueuedObserver<R> m;
+        int n;
+
+        ConcatMapEagerMainObserver(Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> function, int i, int i2, ErrorMode errorMode) {
+            this.a = observer;
+            this.b = function;
+            this.c = i;
+            this.d = i2;
+            this.e = errorMode;
+        }
+
+        @Override // io.reactivex.internal.observers.InnerQueuedObserverSupport
+        public void a(InnerQueuedObserver<R> innerQueuedObserver, R r) {
+            innerQueuedObserver.queue().offer(r);
+            a();
+        }
+
+        void b() {
+            InnerQueuedObserver<R> innerQueuedObserver = this.m;
+            if (innerQueuedObserver != null) {
+                innerQueuedObserver.dispose();
+            }
+            while (true) {
+                InnerQueuedObserver<R> poll = this.g.poll();
+                if (poll == null) {
+                    return;
+                } else {
+                    poll.dispose();
+                }
+            }
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.l = true;
+            if (getAndIncrement() == 0) {
+                this.h.clear();
+                b();
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.j = true;
+            a();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (!this.f.addThrowable(th)) {
+                RxJavaPlugins.b(th);
+            } else {
+                this.j = true;
+                a();
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            if (this.k == 0) {
+                this.h.offer(t);
+            }
+            a();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.i, disposable)) {
+                this.i = disposable;
+                if (disposable instanceof QueueDisposable) {
+                    QueueDisposable queueDisposable = (QueueDisposable) disposable;
+                    int requestFusion = queueDisposable.requestFusion(3);
+                    if (requestFusion == 1) {
+                        this.k = requestFusion;
+                        this.h = queueDisposable;
+                        this.j = true;
+                        this.a.onSubscribe(this);
+                        a();
+                        return;
+                    }
+                    if (requestFusion == 2) {
+                        this.k = requestFusion;
+                        this.h = queueDisposable;
+                        this.a.onSubscribe(this);
+                        return;
+                    }
+                }
+                this.h = new SpscLinkedArrayQueue(this.d);
+                this.a.onSubscribe(this);
+            }
+        }
+
+        @Override // io.reactivex.internal.observers.InnerQueuedObserverSupport
+        public void a(InnerQueuedObserver<R> innerQueuedObserver, Throwable th) {
+            if (this.f.addThrowable(th)) {
+                if (this.e == ErrorMode.IMMEDIATE) {
+                    this.i.dispose();
+                }
+                innerQueuedObserver.setDone();
+                a();
+                return;
+            }
+            RxJavaPlugins.b(th);
+        }
+
+        @Override // io.reactivex.internal.observers.InnerQueuedObserverSupport
+        public void a(InnerQueuedObserver<R> innerQueuedObserver) {
+            innerQueuedObserver.setDone();
+            a();
+        }
+
+        @Override // io.reactivex.internal.observers.InnerQueuedObserverSupport
+        public void a() {
+            R poll;
+            boolean z;
+            if (getAndIncrement() != 0) {
+                return;
+            }
+            SimpleQueue<T> simpleQueue = this.h;
+            ArrayDeque<InnerQueuedObserver<R>> arrayDeque = this.g;
+            Observer<? super R> observer = this.a;
+            ErrorMode errorMode = this.e;
+            int i = 1;
+            while (true) {
+                int i2 = this.n;
+                while (i2 != this.c) {
+                    if (this.l) {
+                        simpleQueue.clear();
+                        b();
+                        return;
+                    }
+                    if (errorMode == ErrorMode.IMMEDIATE && this.f.get() != null) {
+                        simpleQueue.clear();
+                        b();
+                        observer.onError(this.f.terminate());
+                        return;
+                    }
+                    try {
+                        T poll2 = simpleQueue.poll();
+                        if (poll2 == null) {
+                            break;
+                        }
+                        ObservableSource<? extends R> apply = this.b.apply(poll2);
+                        ObjectHelper.a(apply, "The mapper returned a null ObservableSource");
+                        ObservableSource<? extends R> observableSource = apply;
+                        InnerQueuedObserver<R> innerQueuedObserver = new InnerQueuedObserver<>(this, this.d);
+                        arrayDeque.offer(innerQueuedObserver);
+                        observableSource.subscribe(innerQueuedObserver);
+                        i2++;
+                    } catch (Throwable th) {
+                        Exceptions.b(th);
+                        this.i.dispose();
+                        simpleQueue.clear();
+                        b();
+                        this.f.addThrowable(th);
+                        observer.onError(this.f.terminate());
+                        return;
+                    }
+                }
+                this.n = i2;
+                if (this.l) {
+                    simpleQueue.clear();
+                    b();
+                    return;
+                }
+                if (errorMode == ErrorMode.IMMEDIATE && this.f.get() != null) {
+                    simpleQueue.clear();
+                    b();
+                    observer.onError(this.f.terminate());
+                    return;
+                }
+                InnerQueuedObserver<R> innerQueuedObserver2 = this.m;
+                if (innerQueuedObserver2 == null) {
+                    if (errorMode == ErrorMode.BOUNDARY && this.f.get() != null) {
+                        simpleQueue.clear();
+                        b();
+                        observer.onError(this.f.terminate());
+                        return;
+                    }
+                    boolean z2 = this.j;
+                    InnerQueuedObserver<R> poll3 = arrayDeque.poll();
+                    boolean z3 = poll3 == null;
+                    if (z2 && z3) {
+                        if (this.f.get() != null) {
+                            simpleQueue.clear();
+                            b();
+                            observer.onError(this.f.terminate());
+                            return;
+                        }
+                        observer.onComplete();
+                        return;
+                    }
+                    if (!z3) {
+                        this.m = poll3;
+                    }
+                    innerQueuedObserver2 = poll3;
+                }
+                if (innerQueuedObserver2 != null) {
+                    SimpleQueue<R> queue = innerQueuedObserver2.queue();
+                    while (!this.l) {
+                        boolean isDone = innerQueuedObserver2.isDone();
+                        if (errorMode == ErrorMode.IMMEDIATE && this.f.get() != null) {
+                            simpleQueue.clear();
+                            b();
+                            observer.onError(this.f.terminate());
+                            return;
+                        }
+                        try {
+                            poll = queue.poll();
+                            z = poll == null;
+                        } catch (Throwable th2) {
+                            Exceptions.b(th2);
+                            this.f.addThrowable(th2);
+                            this.m = null;
+                            this.n--;
+                        }
+                        if (isDone && z) {
+                            this.m = null;
+                            this.n--;
+                        } else if (!z) {
+                            observer.onNext(poll);
+                        }
+                    }
+                    simpleQueue.clear();
+                    b();
+                    return;
+                }
+                i = addAndGet(-i);
+                if (i == 0) {
+                    return;
+                }
+            }
+        }
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableConcatWithCompletable.java

@@ -0,0 +1,71 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.CompletableObserver;
+import io.reactivex.CompletableSource;
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableConcatWithCompletable<T> extends AbstractObservableWithUpstream<T, T> {
+    final CompletableSource b;
+
+    static final class ConcatWithObserver<T> extends AtomicReference<Disposable> implements Observer<T>, CompletableObserver, Disposable {
+        final Observer<? super T> a;
+        CompletableSource b;
+        boolean c;
+
+        ConcatWithObserver(Observer<? super T> observer, CompletableSource completableSource) {
+            this.a = observer;
+            this.b = completableSource;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            DisposableHelper.dispose(this);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            if (this.c) {
+                this.a.onComplete();
+                return;
+            }
+            this.c = true;
+            DisposableHelper.replace(this, null);
+            CompletableSource completableSource = this.b;
+            this.b = null;
+            completableSource.a(this);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            this.a.onError(th);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            this.a.onNext(t);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (!DisposableHelper.setOnce(this, disposable) || this.c) {
+                return;
+            }
+            this.a.onSubscribe(this);
+        }
+    }
+
+    public ObservableConcatWithCompletable(Observable<T> observable, CompletableSource completableSource) {
+        super(observable);
+        this.b = completableSource;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super T> observer) {
+        this.a.subscribe(new ConcatWithObserver(observer, this.b));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableConcatWithMaybe.java

@@ -0,0 +1,77 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.MaybeObserver;
+import io.reactivex.MaybeSource;
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableConcatWithMaybe<T> extends AbstractObservableWithUpstream<T, T> {
+    final MaybeSource<? extends T> b;
+
+    static final class ConcatWithObserver<T> extends AtomicReference<Disposable> implements Observer<T>, MaybeObserver<T>, Disposable {
+        final Observer<? super T> a;
+        MaybeSource<? extends T> b;
+        boolean c;
+
+        ConcatWithObserver(Observer<? super T> observer, MaybeSource<? extends T> maybeSource) {
+            this.a = observer;
+            this.b = maybeSource;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            DisposableHelper.dispose(this);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            if (this.c) {
+                this.a.onComplete();
+                return;
+            }
+            this.c = true;
+            DisposableHelper.replace(this, null);
+            MaybeSource<? extends T> maybeSource = this.b;
+            this.b = null;
+            maybeSource.a(this);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            this.a.onError(th);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            this.a.onNext(t);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (!DisposableHelper.setOnce(this, disposable) || this.c) {
+                return;
+            }
+            this.a.onSubscribe(this);
+        }
+
+        @Override // io.reactivex.MaybeObserver
+        public void onSuccess(T t) {
+            this.a.onNext(t);
+            this.a.onComplete();
+        }
+    }
+
+    public ObservableConcatWithMaybe(Observable<T> observable, MaybeSource<? extends T> maybeSource) {
+        super(observable);
+        this.b = maybeSource;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super T> observer) {
+        this.a.subscribe(new ConcatWithObserver(observer, this.b));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableConcatWithSingle.java

@@ -0,0 +1,73 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.SingleObserver;
+import io.reactivex.SingleSource;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableConcatWithSingle<T> extends AbstractObservableWithUpstream<T, T> {
+    final SingleSource<? extends T> b;
+
+    static final class ConcatWithObserver<T> extends AtomicReference<Disposable> implements Observer<T>, SingleObserver<T>, Disposable {
+        final Observer<? super T> a;
+        SingleSource<? extends T> b;
+        boolean c;
+
+        ConcatWithObserver(Observer<? super T> observer, SingleSource<? extends T> singleSource) {
+            this.a = observer;
+            this.b = singleSource;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            DisposableHelper.dispose(this);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.c = true;
+            DisposableHelper.replace(this, null);
+            SingleSource<? extends T> singleSource = this.b;
+            this.b = null;
+            singleSource.a(this);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            this.a.onError(th);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            this.a.onNext(t);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (!DisposableHelper.setOnce(this, disposable) || this.c) {
+                return;
+            }
+            this.a.onSubscribe(this);
+        }
+
+        @Override // io.reactivex.SingleObserver
+        public void onSuccess(T t) {
+            this.a.onNext(t);
+            this.a.onComplete();
+        }
+    }
+
+    public ObservableConcatWithSingle(Observable<T> observable, SingleSource<? extends T> singleSource) {
+        super(observable);
+        this.b = singleSource;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super T> observer) {
+        this.a.subscribe(new ConcatWithObserver(observer, this.b));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableCount.java

@@ -0,0 +1,58 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+
+/* loaded from: classes2.dex */
+public final class ObservableCount<T> extends AbstractObservableWithUpstream<T, Long> {
+
+    static final class CountObserver implements Observer<Object>, Disposable {
+        final Observer<? super Long> a;
+        Disposable b;
+        long c;
+
+        CountObserver(Observer<? super Long> observer) {
+            this.a = observer;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.b.dispose();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.a.onNext(Long.valueOf(this.c));
+            this.a.onComplete();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            this.a.onError(th);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(Object obj) {
+            this.c++;
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.b, disposable)) {
+                this.b = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+    }
+
+    public ObservableCount(ObservableSource<T> observableSource) {
+        super(observableSource);
+    }
+
+    @Override // io.reactivex.Observable
+    public void subscribeActual(Observer<? super Long> observer) {
+        this.a.subscribe(new CountObserver(observer));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableCountSingle.java

@@ -0,0 +1,71 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Observable;
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.Single;
+import io.reactivex.SingleObserver;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.fuseable.FuseToObservable;
+import io.reactivex.plugins.RxJavaPlugins;
+
+/* loaded from: classes2.dex */
+public final class ObservableCountSingle<T> extends Single<Long> implements FuseToObservable<Long> {
+    final ObservableSource<T> a;
+
+    static final class CountObserver implements Observer<Object>, Disposable {
+        final SingleObserver<? super Long> a;
+        Disposable b;
+        long c;
+
+        CountObserver(SingleObserver<? super Long> singleObserver) {
+            this.a = singleObserver;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.b.dispose();
+            this.b = DisposableHelper.DISPOSED;
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.b = DisposableHelper.DISPOSED;
+            this.a.onSuccess(Long.valueOf(this.c));
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            this.b = DisposableHelper.DISPOSED;
+            this.a.onError(th);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(Object obj) {
+            this.c++;
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.b, disposable)) {
+                this.b = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+    }
+
+    public ObservableCountSingle(ObservableSource<T> observableSource) {
+        this.a = observableSource;
+    }
+
+    @Override // io.reactivex.internal.fuseable.FuseToObservable
+    public Observable<Long> a() {
+        return RxJavaPlugins.a(new ObservableCount(this.a));
+    }
+
+    @Override // io.reactivex.Single
+    public void b(SingleObserver<? super Long> singleObserver) {
+        this.a.subscribe(new CountObserver(singleObserver));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableCreate.java

@@ -0,0 +1,103 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Observable;
+import io.reactivex.ObservableEmitter;
+import io.reactivex.ObservableOnSubscribe;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableCreate<T> extends Observable<T> {
+    final ObservableOnSubscribe<T> a;
+
+    public ObservableCreate(ObservableOnSubscribe<T> observableOnSubscribe) {
+        this.a = observableOnSubscribe;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super T> observer) {
+        CreateEmitter createEmitter = new CreateEmitter(observer);
+        observer.onSubscribe(createEmitter);
+        try {
+            this.a.subscribe(createEmitter);
+        } catch (Throwable th) {
+            Exceptions.b(th);
+            createEmitter.onError(th);
+        }
+    }
+
+    static final class CreateEmitter<T> extends AtomicReference<Disposable> implements ObservableEmitter<T>, Disposable {
+        final Observer<? super T> a;
+
+        CreateEmitter(Observer<? super T> observer) {
+            this.a = observer;
+        }
+
+        public boolean a(Throwable th) {
+            if (th == null) {
+                th = new NullPointerException("onError called with null. Null values are generally not allowed in 2.x operators and sources.");
+            }
+            if (a()) {
+                return false;
+            }
+            try {
+                this.a.onError(th);
+                dispose();
+                return true;
+            } catch (Throwable th2) {
+                dispose();
+                throw th2;
+            }
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            DisposableHelper.dispose(this);
+        }
+
+        @Override // io.reactivex.Emitter
+        public void onComplete() {
+            if (a()) {
+                return;
+            }
+            try {
+                this.a.onComplete();
+            } finally {
+                dispose();
+            }
+        }
+
+        @Override // io.reactivex.Emitter
+        public void onError(Throwable th) {
+            if (a(th)) {
+                return;
+            }
+            RxJavaPlugins.b(th);
+        }
+
+        @Override // io.reactivex.Emitter
+        public void onNext(T t) {
+            if (t == null) {
+                onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
+            } else {
+                if (a()) {
+                    return;
+                }
+                this.a.onNext(t);
+            }
+        }
+
+        @Override // java.util.concurrent.atomic.AtomicReference
+        public String toString() {
+            return String.format("%s{%s}", CreateEmitter.class.getSimpleName(), super.toString());
+        }
+
+        public boolean a() {
+            return DisposableHelper.isDisposed(get());
+        }
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableDebounce.java

@@ -0,0 +1,158 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Function;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.observers.DisposableObserver;
+import io.reactivex.observers.SerializedObserver;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableDebounce<T, U> extends AbstractObservableWithUpstream<T, T> {
+    final Function<? super T, ? extends ObservableSource<U>> b;
+
+    static final class DebounceObserver<T, U> implements Observer<T>, Disposable {
+        final Observer<? super T> a;
+        final Function<? super T, ? extends ObservableSource<U>> b;
+        Disposable c;
+        final AtomicReference<Disposable> d = new AtomicReference<>();
+        volatile long e;
+        boolean f;
+
+        static final class DebounceInnerObserver<T, U> extends DisposableObserver<U> {
+            final DebounceObserver<T, U> b;
+            final long c;
+            final T d;
+            boolean e;
+            final AtomicBoolean f = new AtomicBoolean();
+
+            DebounceInnerObserver(DebounceObserver<T, U> debounceObserver, long j, T t) {
+                this.b = debounceObserver;
+                this.c = j;
+                this.d = t;
+            }
+
+            void b() {
+                if (this.f.compareAndSet(false, true)) {
+                    this.b.a(this.c, this.d);
+                }
+            }
+
+            @Override // io.reactivex.Observer
+            public void onComplete() {
+                if (this.e) {
+                    return;
+                }
+                this.e = true;
+                b();
+            }
+
+            @Override // io.reactivex.Observer
+            public void onError(Throwable th) {
+                if (this.e) {
+                    RxJavaPlugins.b(th);
+                } else {
+                    this.e = true;
+                    this.b.onError(th);
+                }
+            }
+
+            @Override // io.reactivex.Observer
+            public void onNext(U u) {
+                if (this.e) {
+                    return;
+                }
+                this.e = true;
+                dispose();
+                b();
+            }
+        }
+
+        DebounceObserver(Observer<? super T> observer, Function<? super T, ? extends ObservableSource<U>> function) {
+            this.a = observer;
+            this.b = function;
+        }
+
+        void a(long j, T t) {
+            if (j == this.e) {
+                this.a.onNext(t);
+            }
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.c.dispose();
+            DisposableHelper.dispose(this.d);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            if (this.f) {
+                return;
+            }
+            this.f = true;
+            Disposable disposable = this.d.get();
+            if (disposable != DisposableHelper.DISPOSED) {
+                ((DebounceInnerObserver) disposable).b();
+                DisposableHelper.dispose(this.d);
+                this.a.onComplete();
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            DisposableHelper.dispose(this.d);
+            this.a.onError(th);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            if (this.f) {
+                return;
+            }
+            long j = this.e + 1;
+            this.e = j;
+            Disposable disposable = this.d.get();
+            if (disposable != null) {
+                disposable.dispose();
+            }
+            try {
+                ObservableSource<U> apply = this.b.apply(t);
+                ObjectHelper.a(apply, "The ObservableSource supplied is null");
+                ObservableSource<U> observableSource = apply;
+                DebounceInnerObserver debounceInnerObserver = new DebounceInnerObserver(this, j, t);
+                if (this.d.compareAndSet(disposable, debounceInnerObserver)) {
+                    observableSource.subscribe(debounceInnerObserver);
+                }
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                dispose();
+                this.a.onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.c, disposable)) {
+                this.c = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+    }
+
+    public ObservableDebounce(ObservableSource<T> observableSource, Function<? super T, ? extends ObservableSource<U>> function) {
+        super(observableSource);
+        this.b = function;
+    }
+
+    @Override // io.reactivex.Observable
+    public void subscribeActual(Observer<? super T> observer) {
+        this.a.subscribe(new DebounceObserver(new SerializedObserver(observer), this.b));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableDebounceTimed.java

@@ -0,0 +1,148 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.Scheduler;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.observers.SerializedObserver;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableDebounceTimed<T> extends AbstractObservableWithUpstream<T, T> {
+    final long b;
+    final TimeUnit c;
+    final Scheduler d;
+
+    static final class DebounceEmitter<T> extends AtomicReference<Disposable> implements Runnable, Disposable {
+        final T a;
+        final long b;
+        final DebounceTimedObserver<T> c;
+        final AtomicBoolean d = new AtomicBoolean();
+
+        DebounceEmitter(T t, long j, DebounceTimedObserver<T> debounceTimedObserver) {
+            this.a = t;
+            this.b = j;
+            this.c = debounceTimedObserver;
+        }
+
+        public void a(Disposable disposable) {
+            DisposableHelper.replace(this, disposable);
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            DisposableHelper.dispose(this);
+        }
+
+        @Override // java.lang.Runnable
+        public void run() {
+            if (this.d.compareAndSet(false, true)) {
+                this.c.a(this.b, this.a, this);
+            }
+        }
+    }
+
+    static final class DebounceTimedObserver<T> implements Observer<T>, Disposable {
+        final Observer<? super T> a;
+        final long b;
+        final TimeUnit c;
+        final Scheduler.Worker d;
+        Disposable e;
+        Disposable f;
+        volatile long g;
+        boolean h;
+
+        DebounceTimedObserver(Observer<? super T> observer, long j, TimeUnit timeUnit, Scheduler.Worker worker) {
+            this.a = observer;
+            this.b = j;
+            this.c = timeUnit;
+            this.d = worker;
+        }
+
+        void a(long j, T t, DebounceEmitter<T> debounceEmitter) {
+            if (j == this.g) {
+                this.a.onNext(t);
+                debounceEmitter.dispose();
+            }
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.e.dispose();
+            this.d.dispose();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            if (this.h) {
+                return;
+            }
+            this.h = true;
+            Disposable disposable = this.f;
+            if (disposable != null) {
+                disposable.dispose();
+            }
+            DebounceEmitter debounceEmitter = (DebounceEmitter) disposable;
+            if (debounceEmitter != null) {
+                debounceEmitter.run();
+            }
+            this.a.onComplete();
+            this.d.dispose();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (this.h) {
+                RxJavaPlugins.b(th);
+                return;
+            }
+            Disposable disposable = this.f;
+            if (disposable != null) {
+                disposable.dispose();
+            }
+            this.h = true;
+            this.a.onError(th);
+            this.d.dispose();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            if (this.h) {
+                return;
+            }
+            long j = this.g + 1;
+            this.g = j;
+            Disposable disposable = this.f;
+            if (disposable != null) {
+                disposable.dispose();
+            }
+            DebounceEmitter debounceEmitter = new DebounceEmitter(t, j, this);
+            this.f = debounceEmitter;
+            debounceEmitter.a(this.d.a(debounceEmitter, this.b, this.c));
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.e, disposable)) {
+                this.e = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+    }
+
+    public ObservableDebounceTimed(ObservableSource<T> observableSource, long j, TimeUnit timeUnit, Scheduler scheduler) {
+        super(observableSource);
+        this.b = j;
+        this.c = timeUnit;
+        this.d = scheduler;
+    }
+
+    @Override // io.reactivex.Observable
+    public void subscribeActual(Observer<? super T> observer) {
+        this.a.subscribe(new DebounceTimedObserver(new SerializedObserver(observer), this.b, this.c, this.d.a()));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableDefer.java

@@ -0,0 +1,30 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Observable;
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.internal.disposables.EmptyDisposable;
+import io.reactivex.internal.functions.ObjectHelper;
+import java.util.concurrent.Callable;
+
+/* loaded from: classes2.dex */
+public final class ObservableDefer<T> extends Observable<T> {
+    final Callable<? extends ObservableSource<? extends T>> a;
+
+    public ObservableDefer(Callable<? extends ObservableSource<? extends T>> callable) {
+        this.a = callable;
+    }
+
+    @Override // io.reactivex.Observable
+    public void subscribeActual(Observer<? super T> observer) {
+        try {
+            ObservableSource<? extends T> call = this.a.call();
+            ObjectHelper.a(call, "null ObservableSource supplied");
+            call.subscribe(observer);
+        } catch (Throwable th) {
+            Exceptions.b(th);
+            EmptyDisposable.error(th, observer);
+        }
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableDelay.java

@@ -0,0 +1,120 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.Scheduler;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.observers.SerializedObserver;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes2.dex */
+public final class ObservableDelay<T> extends AbstractObservableWithUpstream<T, T> {
+    final long b;
+    final TimeUnit c;
+    final Scheduler d;
+    final boolean e;
+
+    static final class DelayObserver<T> implements Observer<T>, Disposable {
+        final Observer<? super T> a;
+        final long b;
+        final TimeUnit c;
+        final Scheduler.Worker d;
+        final boolean e;
+        Disposable f;
+
+        final class OnComplete implements Runnable {
+            OnComplete() {
+            }
+
+            @Override // java.lang.Runnable
+            public void run() {
+                try {
+                    DelayObserver.this.a.onComplete();
+                } finally {
+                    DelayObserver.this.d.dispose();
+                }
+            }
+        }
+
+        final class OnError implements Runnable {
+            private final Throwable a;
+
+            OnError(Throwable th) {
+                this.a = th;
+            }
+
+            @Override // java.lang.Runnable
+            public void run() {
+                try {
+                    DelayObserver.this.a.onError(this.a);
+                } finally {
+                    DelayObserver.this.d.dispose();
+                }
+            }
+        }
+
+        final class OnNext implements Runnable {
+            private final T a;
+
+            OnNext(T t) {
+                this.a = t;
+            }
+
+            @Override // java.lang.Runnable
+            public void run() {
+                DelayObserver.this.a.onNext(this.a);
+            }
+        }
+
+        DelayObserver(Observer<? super T> observer, long j, TimeUnit timeUnit, Scheduler.Worker worker, boolean z) {
+            this.a = observer;
+            this.b = j;
+            this.c = timeUnit;
+            this.d = worker;
+            this.e = z;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.f.dispose();
+            this.d.dispose();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.d.a(new OnComplete(), this.b, this.c);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            this.d.a(new OnError(th), this.e ? this.b : 0L, this.c);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            this.d.a(new OnNext(t), this.b, this.c);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.f, disposable)) {
+                this.f = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+    }
+
+    public ObservableDelay(ObservableSource<T> observableSource, long j, TimeUnit timeUnit, Scheduler scheduler, boolean z) {
+        super(observableSource);
+        this.b = j;
+        this.c = timeUnit;
+        this.d = scheduler;
+        this.e = z;
+    }
+
+    @Override // io.reactivex.Observable
+    public void subscribeActual(Observer<? super T> observer) {
+        this.a.subscribe(new DelayObserver(this.e ? observer : new SerializedObserver(observer), this.b, this.c, this.d.a(), this.e));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableDelaySubscriptionOther.java

@@ -0,0 +1,91 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Observable;
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.SequentialDisposable;
+import io.reactivex.plugins.RxJavaPlugins;
+
+/* loaded from: classes2.dex */
+public final class ObservableDelaySubscriptionOther<T, U> extends Observable<T> {
+    final ObservableSource<? extends T> a;
+    final ObservableSource<U> b;
+
+    final class DelayObserver implements Observer<U> {
+        final SequentialDisposable a;
+        final Observer<? super T> b;
+        boolean c;
+
+        final class OnComplete implements Observer<T> {
+            OnComplete() {
+            }
+
+            @Override // io.reactivex.Observer
+            public void onComplete() {
+                DelayObserver.this.b.onComplete();
+            }
+
+            @Override // io.reactivex.Observer
+            public void onError(Throwable th) {
+                DelayObserver.this.b.onError(th);
+            }
+
+            @Override // io.reactivex.Observer
+            public void onNext(T t) {
+                DelayObserver.this.b.onNext(t);
+            }
+
+            @Override // io.reactivex.Observer
+            public void onSubscribe(Disposable disposable) {
+                DelayObserver.this.a.update(disposable);
+            }
+        }
+
+        DelayObserver(SequentialDisposable sequentialDisposable, Observer<? super T> observer) {
+            this.a = sequentialDisposable;
+            this.b = observer;
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            if (this.c) {
+                return;
+            }
+            this.c = true;
+            ObservableDelaySubscriptionOther.this.a.subscribe(new OnComplete());
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (this.c) {
+                RxJavaPlugins.b(th);
+            } else {
+                this.c = true;
+                this.b.onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(U u) {
+            onComplete();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            this.a.update(disposable);
+        }
+    }
+
+    public ObservableDelaySubscriptionOther(ObservableSource<? extends T> observableSource, ObservableSource<U> observableSource2) {
+        this.a = observableSource;
+        this.b = observableSource2;
+    }
+
+    @Override // io.reactivex.Observable
+    public void subscribeActual(Observer<? super T> observer) {
+        SequentialDisposable sequentialDisposable = new SequentialDisposable();
+        observer.onSubscribe(sequentialDisposable);
+        this.b.subscribe(new DelayObserver(sequentialDisposable, observer));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableDematerialize.java

@@ -0,0 +1,81 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Notification;
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.plugins.RxJavaPlugins;
+
+/* loaded from: classes2.dex */
+public final class ObservableDematerialize<T> extends AbstractObservableWithUpstream<Notification<T>, T> {
+
+    static final class DematerializeObserver<T> implements Observer<Notification<T>>, Disposable {
+        final Observer<? super T> a;
+        boolean b;
+        Disposable c;
+
+        DematerializeObserver(Observer<? super T> observer) {
+            this.a = observer;
+        }
+
+        @Override // io.reactivex.Observer
+        /* renamed from: a, reason: merged with bridge method [inline-methods] */
+        public void onNext(Notification<T> notification) {
+            if (this.b) {
+                if (notification.d()) {
+                    RxJavaPlugins.b(notification.a());
+                }
+            } else if (notification.d()) {
+                this.c.dispose();
+                onError(notification.a());
+            } else if (!notification.c()) {
+                this.a.onNext(notification.b());
+            } else {
+                this.c.dispose();
+                onComplete();
+            }
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.c.dispose();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            if (this.b) {
+                return;
+            }
+            this.b = true;
+            this.a.onComplete();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (this.b) {
+                RxJavaPlugins.b(th);
+            } else {
+                this.b = true;
+                this.a.onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.c, disposable)) {
+                this.c = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+    }
+
+    public ObservableDematerialize(ObservableSource<Notification<T>> observableSource) {
+        super(observableSource);
+    }
+
+    @Override // io.reactivex.Observable
+    public void subscribeActual(Observer<? super T> observer) {
+        this.a.subscribe(new DematerializeObserver(observer));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableDetach.java

@@ -0,0 +1,66 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.util.EmptyComponent;
+
+/* loaded from: classes2.dex */
+public final class ObservableDetach<T> extends AbstractObservableWithUpstream<T, T> {
+
+    static final class DetachObserver<T> implements Observer<T>, Disposable {
+        Observer<? super T> a;
+        Disposable b;
+
+        DetachObserver(Observer<? super T> observer) {
+            this.a = observer;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            Disposable disposable = this.b;
+            this.b = EmptyComponent.INSTANCE;
+            this.a = EmptyComponent.asObserver();
+            disposable.dispose();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            Observer<? super T> observer = this.a;
+            this.b = EmptyComponent.INSTANCE;
+            this.a = EmptyComponent.asObserver();
+            observer.onComplete();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            Observer<? super T> observer = this.a;
+            this.b = EmptyComponent.INSTANCE;
+            this.a = EmptyComponent.asObserver();
+            observer.onError(th);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            this.a.onNext(t);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.b, disposable)) {
+                this.b = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+    }
+
+    public ObservableDetach(ObservableSource<T> observableSource) {
+        super(observableSource);
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super T> observer) {
+        this.a.subscribe(new DetachObserver(observer));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableDistinct.java

@@ -0,0 +1,116 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Function;
+import io.reactivex.internal.disposables.EmptyDisposable;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.observers.BasicFuseableObserver;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.Collection;
+import java.util.concurrent.Callable;
+
+/* loaded from: classes2.dex */
+public final class ObservableDistinct<T, K> extends AbstractObservableWithUpstream<T, T> {
+    final Function<? super T, K> b;
+    final Callable<? extends Collection<? super K>> c;
+
+    static final class DistinctObserver<T, K> extends BasicFuseableObserver<T, T> {
+        final Collection<? super K> f;
+        final Function<? super T, K> g;
+
+        DistinctObserver(Observer<? super T> observer, Function<? super T, K> function, Collection<? super K> collection) {
+            super(observer);
+            this.g = function;
+            this.f = collection;
+        }
+
+        @Override // io.reactivex.internal.observers.BasicFuseableObserver, io.reactivex.internal.fuseable.SimpleQueue
+        public void clear() {
+            this.f.clear();
+            super.clear();
+        }
+
+        @Override // io.reactivex.internal.observers.BasicFuseableObserver, io.reactivex.Observer
+        public void onComplete() {
+            if (this.d) {
+                return;
+            }
+            this.d = true;
+            this.f.clear();
+            this.a.onComplete();
+        }
+
+        @Override // io.reactivex.internal.observers.BasicFuseableObserver, io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (this.d) {
+                RxJavaPlugins.b(th);
+                return;
+            }
+            this.d = true;
+            this.f.clear();
+            this.a.onError(th);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            if (this.d) {
+                return;
+            }
+            if (this.e != 0) {
+                this.a.onNext(null);
+                return;
+            }
+            try {
+                K apply = this.g.apply(t);
+                ObjectHelper.a(apply, "The keySelector returned a null key");
+                if (this.f.add(apply)) {
+                    this.a.onNext(t);
+                }
+            } catch (Throwable th) {
+                a(th);
+            }
+        }
+
+        @Override // io.reactivex.internal.fuseable.SimpleQueue
+        public T poll() throws Exception {
+            T poll;
+            Collection<? super K> collection;
+            K apply;
+            do {
+                poll = this.c.poll();
+                if (poll == null) {
+                    break;
+                }
+                collection = this.f;
+                apply = this.g.apply(poll);
+                ObjectHelper.a(apply, "The keySelector returned a null key");
+            } while (!collection.add(apply));
+            return poll;
+        }
+
+        @Override // io.reactivex.internal.fuseable.QueueFuseable
+        public int requestFusion(int i) {
+            return a(i);
+        }
+    }
+
+    public ObservableDistinct(ObservableSource<T> observableSource, Function<? super T, K> function, Callable<? extends Collection<? super K>> callable) {
+        super(observableSource);
+        this.b = function;
+        this.c = callable;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super T> observer) {
+        try {
+            Collection<? super K> call = this.c.call();
+            ObjectHelper.a(call, "The collectionSupplier returned a null collection. Null values are generally not allowed in 2.x operators and sources.");
+            this.a.subscribe(new DistinctObserver(observer, this.b, call));
+        } catch (Throwable th) {
+            Exceptions.b(th);
+            EmptyDisposable.error(th, observer);
+        }
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableDistinctUntilChanged.java

@@ -0,0 +1,90 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.functions.BiPredicate;
+import io.reactivex.functions.Function;
+import io.reactivex.internal.observers.BasicFuseableObserver;
+
+/* loaded from: classes2.dex */
+public final class ObservableDistinctUntilChanged<T, K> extends AbstractObservableWithUpstream<T, T> {
+    final Function<? super T, K> b;
+    final BiPredicate<? super K, ? super K> c;
+
+    static final class DistinctUntilChangedObserver<T, K> extends BasicFuseableObserver<T, T> {
+        final Function<? super T, K> f;
+        final BiPredicate<? super K, ? super K> g;
+        K h;
+        boolean i;
+
+        DistinctUntilChangedObserver(Observer<? super T> observer, Function<? super T, K> function, BiPredicate<? super K, ? super K> biPredicate) {
+            super(observer);
+            this.f = function;
+            this.g = biPredicate;
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            if (this.d) {
+                return;
+            }
+            if (this.e != 0) {
+                this.a.onNext(t);
+                return;
+            }
+            try {
+                K apply = this.f.apply(t);
+                if (this.i) {
+                    boolean a = this.g.a(this.h, apply);
+                    this.h = apply;
+                    if (a) {
+                        return;
+                    }
+                } else {
+                    this.i = true;
+                    this.h = apply;
+                }
+                this.a.onNext(t);
+            } catch (Throwable th) {
+                a(th);
+            }
+        }
+
+        @Override // io.reactivex.internal.fuseable.SimpleQueue
+        public T poll() throws Exception {
+            while (true) {
+                T poll = this.c.poll();
+                if (poll == null) {
+                    return null;
+                }
+                K apply = this.f.apply(poll);
+                if (!this.i) {
+                    this.i = true;
+                    this.h = apply;
+                    return poll;
+                }
+                if (!this.g.a(this.h, apply)) {
+                    this.h = apply;
+                    return poll;
+                }
+                this.h = apply;
+            }
+        }
+
+        @Override // io.reactivex.internal.fuseable.QueueFuseable
+        public int requestFusion(int i) {
+            return a(i);
+        }
+    }
+
+    public ObservableDistinctUntilChanged(ObservableSource<T> observableSource, Function<? super T, K> function, BiPredicate<? super K, ? super K> biPredicate) {
+        super(observableSource);
+        this.b = function;
+        this.c = biPredicate;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super T> observer) {
+        this.a.subscribe(new DistinctUntilChangedObserver(observer, this.b, this.c));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableDoAfterNext.java

@@ -0,0 +1,56 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.functions.Consumer;
+import io.reactivex.internal.observers.BasicFuseableObserver;
+
+/* loaded from: classes2.dex */
+public final class ObservableDoAfterNext<T> extends AbstractObservableWithUpstream<T, T> {
+    final Consumer<? super T> b;
+
+    static final class DoAfterObserver<T> extends BasicFuseableObserver<T, T> {
+        final Consumer<? super T> f;
+
+        DoAfterObserver(Observer<? super T> observer, Consumer<? super T> consumer) {
+            super(observer);
+            this.f = consumer;
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            this.a.onNext(t);
+            if (this.e == 0) {
+                try {
+                    this.f.accept(t);
+                } catch (Throwable th) {
+                    a(th);
+                }
+            }
+        }
+
+        @Override // io.reactivex.internal.fuseable.SimpleQueue
+        public T poll() throws Exception {
+            T poll = this.c.poll();
+            if (poll != null) {
+                this.f.accept(poll);
+            }
+            return poll;
+        }
+
+        @Override // io.reactivex.internal.fuseable.QueueFuseable
+        public int requestFusion(int i) {
+            return a(i);
+        }
+    }
+
+    public ObservableDoAfterNext(ObservableSource<T> observableSource, Consumer<? super T> consumer) {
+        super(observableSource);
+        this.b = consumer;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super T> observer) {
+        this.a.subscribe(new DoAfterObserver(observer, this.b));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableDoFinally.java

@@ -0,0 +1,116 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Action;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.fuseable.QueueDisposable;
+import io.reactivex.internal.observers.BasicIntQueueDisposable;
+import io.reactivex.plugins.RxJavaPlugins;
+
+/* loaded from: classes2.dex */
+public final class ObservableDoFinally<T> extends AbstractObservableWithUpstream<T, T> {
+    final Action b;
+
+    static final class DoFinallyObserver<T> extends BasicIntQueueDisposable<T> implements Observer<T> {
+        final Observer<? super T> a;
+        final Action b;
+        Disposable c;
+        QueueDisposable<T> d;
+        boolean e;
+
+        DoFinallyObserver(Observer<? super T> observer, Action action) {
+            this.a = observer;
+            this.b = action;
+        }
+
+        void a() {
+            if (compareAndSet(0, 1)) {
+                try {
+                    this.b.run();
+                } catch (Throwable th) {
+                    Exceptions.b(th);
+                    RxJavaPlugins.b(th);
+                }
+            }
+        }
+
+        @Override // io.reactivex.internal.fuseable.SimpleQueue
+        public void clear() {
+            this.d.clear();
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.c.dispose();
+            a();
+        }
+
+        @Override // io.reactivex.internal.fuseable.SimpleQueue
+        public boolean isEmpty() {
+            return this.d.isEmpty();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.a.onComplete();
+            a();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            this.a.onError(th);
+            a();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            this.a.onNext(t);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.c, disposable)) {
+                this.c = disposable;
+                if (disposable instanceof QueueDisposable) {
+                    this.d = (QueueDisposable) disposable;
+                }
+                this.a.onSubscribe(this);
+            }
+        }
+
+        @Override // io.reactivex.internal.fuseable.SimpleQueue
+        public T poll() throws Exception {
+            T poll = this.d.poll();
+            if (poll == null && this.e) {
+                a();
+            }
+            return poll;
+        }
+
+        @Override // io.reactivex.internal.fuseable.QueueFuseable
+        public int requestFusion(int i) {
+            QueueDisposable<T> queueDisposable = this.d;
+            if (queueDisposable == null || (i & 4) != 0) {
+                return 0;
+            }
+            int requestFusion = queueDisposable.requestFusion(i);
+            if (requestFusion != 0) {
+                this.e = requestFusion == 1;
+            }
+            return requestFusion;
+        }
+    }
+
+    public ObservableDoFinally(ObservableSource<T> observableSource, Action action) {
+        super(observableSource);
+        this.b = action;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super T> observer) {
+        this.a.subscribe(new DoFinallyObserver(observer, this.b));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableDoOnEach.java

@@ -0,0 +1,121 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.CompositeException;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Action;
+import io.reactivex.functions.Consumer;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.plugins.RxJavaPlugins;
+
+/* loaded from: classes2.dex */
+public final class ObservableDoOnEach<T> extends AbstractObservableWithUpstream<T, T> {
+    final Consumer<? super T> b;
+    final Consumer<? super Throwable> c;
+    final Action d;
+    final Action e;
+
+    static final class DoOnEachObserver<T> implements Observer<T>, Disposable {
+        final Observer<? super T> a;
+        final Consumer<? super T> b;
+        final Consumer<? super Throwable> c;
+        final Action d;
+        final Action e;
+        Disposable f;
+        boolean g;
+
+        DoOnEachObserver(Observer<? super T> observer, Consumer<? super T> consumer, Consumer<? super Throwable> consumer2, Action action, Action action2) {
+            this.a = observer;
+            this.b = consumer;
+            this.c = consumer2;
+            this.d = action;
+            this.e = action2;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.f.dispose();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            if (this.g) {
+                return;
+            }
+            try {
+                this.d.run();
+                this.g = true;
+                this.a.onComplete();
+                try {
+                    this.e.run();
+                } catch (Throwable th) {
+                    Exceptions.b(th);
+                    RxJavaPlugins.b(th);
+                }
+            } catch (Throwable th2) {
+                Exceptions.b(th2);
+                onError(th2);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (this.g) {
+                RxJavaPlugins.b(th);
+                return;
+            }
+            this.g = true;
+            try {
+                this.c.accept(th);
+            } catch (Throwable th2) {
+                Exceptions.b(th2);
+                th = new CompositeException(th, th2);
+            }
+            this.a.onError(th);
+            try {
+                this.e.run();
+            } catch (Throwable th3) {
+                Exceptions.b(th3);
+                RxJavaPlugins.b(th3);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            if (this.g) {
+                return;
+            }
+            try {
+                this.b.accept(t);
+                this.a.onNext(t);
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                this.f.dispose();
+                onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.f, disposable)) {
+                this.f = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+    }
+
+    public ObservableDoOnEach(ObservableSource<T> observableSource, Consumer<? super T> consumer, Consumer<? super Throwable> consumer2, Action action, Action action2) {
+        super(observableSource);
+        this.b = consumer;
+        this.c = consumer2;
+        this.d = action;
+        this.e = action2;
+    }
+
+    @Override // io.reactivex.Observable
+    public void subscribeActual(Observer<? super T> observer) {
+        this.a.subscribe(new DoOnEachObserver(observer, this.b, this.c, this.d, this.e));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableDoOnLifecycle.java

@@ -0,0 +1,25 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.functions.Action;
+import io.reactivex.functions.Consumer;
+import io.reactivex.internal.observers.DisposableLambdaObserver;
+
+/* loaded from: classes2.dex */
+public final class ObservableDoOnLifecycle<T> extends AbstractObservableWithUpstream<T, T> {
+    private final Consumer<? super Disposable> b;
+    private final Action c;
+
+    public ObservableDoOnLifecycle(Observable<T> observable, Consumer<? super Disposable> consumer, Action action) {
+        super(observable);
+        this.b = consumer;
+        this.c = action;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super T> observer) {
+        this.a.subscribe(new DisposableLambdaObserver(observer, this.b, this.c));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableElementAt.java

@@ -0,0 +1,100 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.NoSuchElementException;
+
+/* loaded from: classes2.dex */
+public final class ObservableElementAt<T> extends AbstractObservableWithUpstream<T, T> {
+    final long b;
+    final T c;
+    final boolean d;
+
+    static final class ElementAtObserver<T> implements Observer<T>, Disposable {
+        final Observer<? super T> a;
+        final long b;
+        final T c;
+        final boolean d;
+        Disposable e;
+        long f;
+        boolean g;
+
+        ElementAtObserver(Observer<? super T> observer, long j, T t, boolean z) {
+            this.a = observer;
+            this.b = j;
+            this.c = t;
+            this.d = z;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.e.dispose();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            if (this.g) {
+                return;
+            }
+            this.g = true;
+            T t = this.c;
+            if (t == null && this.d) {
+                this.a.onError(new NoSuchElementException());
+                return;
+            }
+            if (t != null) {
+                this.a.onNext(t);
+            }
+            this.a.onComplete();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (this.g) {
+                RxJavaPlugins.b(th);
+            } else {
+                this.g = true;
+                this.a.onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            if (this.g) {
+                return;
+            }
+            long j = this.f;
+            if (j != this.b) {
+                this.f = j + 1;
+                return;
+            }
+            this.g = true;
+            this.e.dispose();
+            this.a.onNext(t);
+            this.a.onComplete();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.e, disposable)) {
+                this.e = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+    }
+
+    public ObservableElementAt(ObservableSource<T> observableSource, long j, T t, boolean z) {
+        super(observableSource);
+        this.b = j;
+        this.c = t;
+        this.d = z;
+    }
+
+    @Override // io.reactivex.Observable
+    public void subscribeActual(Observer<? super T> observer) {
+        this.a.subscribe(new ElementAtObserver(observer, this.b, this.c, this.d));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableElementAtMaybe.java

@@ -0,0 +1,92 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Maybe;
+import io.reactivex.MaybeObserver;
+import io.reactivex.Observable;
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.fuseable.FuseToObservable;
+import io.reactivex.plugins.RxJavaPlugins;
+
+/* loaded from: classes2.dex */
+public final class ObservableElementAtMaybe<T> extends Maybe<T> implements FuseToObservable<T> {
+    final ObservableSource<T> a;
+    final long b;
+
+    static final class ElementAtObserver<T> implements Observer<T>, Disposable {
+        final MaybeObserver<? super T> a;
+        final long b;
+        Disposable c;
+        long d;
+        boolean e;
+
+        ElementAtObserver(MaybeObserver<? super T> maybeObserver, long j) {
+            this.a = maybeObserver;
+            this.b = j;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.c.dispose();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            if (this.e) {
+                return;
+            }
+            this.e = true;
+            this.a.onComplete();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (this.e) {
+                RxJavaPlugins.b(th);
+            } else {
+                this.e = true;
+                this.a.onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            if (this.e) {
+                return;
+            }
+            long j = this.d;
+            if (j != this.b) {
+                this.d = j + 1;
+                return;
+            }
+            this.e = true;
+            this.c.dispose();
+            this.a.onSuccess(t);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.c, disposable)) {
+                this.c = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+    }
+
+    public ObservableElementAtMaybe(ObservableSource<T> observableSource, long j) {
+        this.a = observableSource;
+        this.b = j;
+    }
+
+    @Override // io.reactivex.internal.fuseable.FuseToObservable
+    public Observable<T> a() {
+        return RxJavaPlugins.a(new ObservableElementAt(this.a, this.b, null, false));
+    }
+
+    @Override // io.reactivex.Maybe
+    public void b(MaybeObserver<? super T> maybeObserver) {
+        this.a.subscribe(new ElementAtObserver(maybeObserver, this.b));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableElementAtSingle.java

@@ -0,0 +1,102 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Observable;
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.Single;
+import io.reactivex.SingleObserver;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.fuseable.FuseToObservable;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.NoSuchElementException;
+
+/* loaded from: classes2.dex */
+public final class ObservableElementAtSingle<T> extends Single<T> implements FuseToObservable<T> {
+    final ObservableSource<T> a;
+    final long b;
+    final T c;
+
+    static final class ElementAtObserver<T> implements Observer<T>, Disposable {
+        final SingleObserver<? super T> a;
+        final long b;
+        final T c;
+        Disposable d;
+        long e;
+        boolean f;
+
+        ElementAtObserver(SingleObserver<? super T> singleObserver, long j, T t) {
+            this.a = singleObserver;
+            this.b = j;
+            this.c = t;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.d.dispose();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            if (this.f) {
+                return;
+            }
+            this.f = true;
+            T t = this.c;
+            if (t != null) {
+                this.a.onSuccess(t);
+            } else {
+                this.a.onError(new NoSuchElementException());
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (this.f) {
+                RxJavaPlugins.b(th);
+            } else {
+                this.f = true;
+                this.a.onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            if (this.f) {
+                return;
+            }
+            long j = this.e;
+            if (j != this.b) {
+                this.e = j + 1;
+                return;
+            }
+            this.f = true;
+            this.d.dispose();
+            this.a.onSuccess(t);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.d, disposable)) {
+                this.d = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+    }
+
+    public ObservableElementAtSingle(ObservableSource<T> observableSource, long j, T t) {
+        this.a = observableSource;
+        this.b = j;
+        this.c = t;
+    }
+
+    @Override // io.reactivex.internal.fuseable.FuseToObservable
+    public Observable<T> a() {
+        return RxJavaPlugins.a(new ObservableElementAt(this.a, this.b, this.c, true));
+    }
+
+    @Override // io.reactivex.Single
+    public void b(SingleObserver<? super T> singleObserver) {
+        this.a.subscribe(new ElementAtObserver(singleObserver, this.b, this.c));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableEmpty.java

@@ -0,0 +1,24 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.internal.disposables.EmptyDisposable;
+import io.reactivex.internal.fuseable.ScalarCallable;
+
+/* loaded from: classes2.dex */
+public final class ObservableEmpty extends Observable<Object> implements ScalarCallable<Object> {
+    public static final Observable<Object> a = new ObservableEmpty();
+
+    private ObservableEmpty() {
+    }
+
+    @Override // io.reactivex.internal.fuseable.ScalarCallable, java.util.concurrent.Callable
+    public Object call() {
+        return null;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super Object> observer) {
+        EmptyDisposable.complete(observer);
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableError.java

@@ -0,0 +1,30 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.internal.disposables.EmptyDisposable;
+import io.reactivex.internal.functions.ObjectHelper;
+import java.util.concurrent.Callable;
+
+/* loaded from: classes2.dex */
+public final class ObservableError<T> extends Observable<T> {
+    final Callable<? extends Throwable> a;
+
+    public ObservableError(Callable<? extends Throwable> callable) {
+        this.a = callable;
+    }
+
+    @Override // io.reactivex.Observable
+    public void subscribeActual(Observer<? super T> observer) {
+        try {
+            Throwable call = this.a.call();
+            ObjectHelper.a(call, "Callable returned null throwable. Null values are generally not allowed in 2.x operators and sources.");
+            th = call;
+        } catch (Throwable th) {
+            th = th;
+            Exceptions.b(th);
+        }
+        EmptyDisposable.error(th, observer);
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableFilter.java

@@ -0,0 +1,62 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.functions.Predicate;
+import io.reactivex.internal.observers.BasicFuseableObserver;
+
+/* loaded from: classes2.dex */
+public final class ObservableFilter<T> extends AbstractObservableWithUpstream<T, T> {
+    final Predicate<? super T> b;
+
+    static final class FilterObserver<T> extends BasicFuseableObserver<T, T> {
+        final Predicate<? super T> f;
+
+        FilterObserver(Observer<? super T> observer, Predicate<? super T> predicate) {
+            super(observer);
+            this.f = predicate;
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            if (this.e != 0) {
+                this.a.onNext(null);
+                return;
+            }
+            try {
+                if (this.f.a(t)) {
+                    this.a.onNext(t);
+                }
+            } catch (Throwable th) {
+                a(th);
+            }
+        }
+
+        @Override // io.reactivex.internal.fuseable.SimpleQueue
+        public T poll() throws Exception {
+            T poll;
+            do {
+                poll = this.c.poll();
+                if (poll == null) {
+                    break;
+                }
+            } while (!this.f.a(poll));
+            return poll;
+        }
+
+        @Override // io.reactivex.internal.fuseable.QueueFuseable
+        public int requestFusion(int i) {
+            return a(i);
+        }
+    }
+
+    public ObservableFilter(ObservableSource<T> observableSource, Predicate<? super T> predicate) {
+        super(observableSource);
+        this.b = predicate;
+    }
+
+    @Override // io.reactivex.Observable
+    public void subscribeActual(Observer<? super T> observer) {
+        this.a.subscribe(new FilterObserver(observer, this.b));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableFlatMap.java

@@ -0,0 +1,524 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Function;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.fuseable.QueueDisposable;
+import io.reactivex.internal.fuseable.SimplePlainQueue;
+import io.reactivex.internal.fuseable.SimpleQueue;
+import io.reactivex.internal.queue.SpscArrayQueue;
+import io.reactivex.internal.queue.SpscLinkedArrayQueue;
+import io.reactivex.internal.util.AtomicThrowable;
+import io.reactivex.internal.util.ExceptionHelper;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.ArrayDeque;
+import java.util.Queue;
+import java.util.concurrent.Callable;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableFlatMap<T, U> extends AbstractObservableWithUpstream<T, U> {
+    final Function<? super T, ? extends ObservableSource<? extends U>> b;
+    final boolean c;
+    final int d;
+    final int e;
+
+    static final class InnerObserver<T, U> extends AtomicReference<Disposable> implements Observer<U> {
+        final long a;
+        final MergeObserver<T, U> b;
+        volatile boolean c;
+        volatile SimpleQueue<U> d;
+        int e;
+
+        InnerObserver(MergeObserver<T, U> mergeObserver, long j) {
+            this.a = j;
+            this.b = mergeObserver;
+        }
+
+        public void a() {
+            DisposableHelper.dispose(this);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.c = true;
+            this.b.c();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (!this.b.h.addThrowable(th)) {
+                RxJavaPlugins.b(th);
+                return;
+            }
+            MergeObserver<T, U> mergeObserver = this.b;
+            if (!mergeObserver.c) {
+                mergeObserver.b();
+            }
+            this.c = true;
+            this.b.c();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(U u) {
+            if (this.e == 0) {
+                this.b.a(u, this);
+            } else {
+                this.b.c();
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.setOnce(this, disposable) && (disposable instanceof QueueDisposable)) {
+                QueueDisposable queueDisposable = (QueueDisposable) disposable;
+                int requestFusion = queueDisposable.requestFusion(7);
+                if (requestFusion == 1) {
+                    this.e = requestFusion;
+                    this.d = queueDisposable;
+                    this.c = true;
+                    this.b.c();
+                    return;
+                }
+                if (requestFusion == 2) {
+                    this.e = requestFusion;
+                    this.d = queueDisposable;
+                }
+            }
+        }
+    }
+
+    public ObservableFlatMap(ObservableSource<T> observableSource, Function<? super T, ? extends ObservableSource<? extends U>> function, boolean z, int i, int i2) {
+        super(observableSource);
+        this.b = function;
+        this.c = z;
+        this.d = i;
+        this.e = i2;
+    }
+
+    @Override // io.reactivex.Observable
+    public void subscribeActual(Observer<? super U> observer) {
+        if (ObservableScalarXMap.a(this.a, observer, this.b)) {
+            return;
+        }
+        this.a.subscribe(new MergeObserver(observer, this.b, this.c, this.d, this.e));
+    }
+
+    static final class MergeObserver<T, U> extends AtomicInteger implements Disposable, Observer<T> {
+        static final InnerObserver<?, ?>[] q = new InnerObserver[0];
+        static final InnerObserver<?, ?>[] r = new InnerObserver[0];
+        final Observer<? super U> a;
+        final Function<? super T, ? extends ObservableSource<? extends U>> b;
+        final boolean c;
+        final int d;
+        final int e;
+        volatile SimplePlainQueue<U> f;
+        volatile boolean g;
+        final AtomicThrowable h = new AtomicThrowable();
+        volatile boolean i;
+        final AtomicReference<InnerObserver<?, ?>[]> j;
+        Disposable k;
+        long l;
+        long m;
+        int n;
+        Queue<ObservableSource<? extends U>> o;
+        int p;
+
+        MergeObserver(Observer<? super U> observer, Function<? super T, ? extends ObservableSource<? extends U>> function, boolean z, int i, int i2) {
+            this.a = observer;
+            this.b = function;
+            this.c = z;
+            this.d = i;
+            this.e = i2;
+            if (i != Integer.MAX_VALUE) {
+                this.o = new ArrayDeque(i);
+            }
+            this.j = new AtomicReference<>(q);
+        }
+
+        void a(ObservableSource<? extends U> observableSource) {
+            ObservableSource<? extends U> poll;
+            while (observableSource instanceof Callable) {
+                if (!a((Callable) observableSource) || this.d == Integer.MAX_VALUE) {
+                    return;
+                }
+                boolean z = false;
+                synchronized (this) {
+                    poll = this.o.poll();
+                    if (poll == null) {
+                        this.p--;
+                        z = true;
+                    }
+                }
+                if (z) {
+                    c();
+                    return;
+                }
+                observableSource = poll;
+            }
+            long j = this.l;
+            this.l = 1 + j;
+            InnerObserver<T, U> innerObserver = new InnerObserver<>(this, j);
+            if (a(innerObserver)) {
+                observableSource.subscribe(innerObserver);
+            }
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        void b(InnerObserver<T, U> innerObserver) {
+            InnerObserver<?, ?>[] innerObserverArr;
+            InnerObserver<?, ?>[] innerObserverArr2;
+            do {
+                innerObserverArr = this.j.get();
+                int length = innerObserverArr.length;
+                if (length == 0) {
+                    return;
+                }
+                int i = -1;
+                int i2 = 0;
+                while (true) {
+                    if (i2 >= length) {
+                        break;
+                    }
+                    if (innerObserverArr[i2] == innerObserver) {
+                        i = i2;
+                        break;
+                    }
+                    i2++;
+                }
+                if (i < 0) {
+                    return;
+                }
+                if (length == 1) {
+                    innerObserverArr2 = q;
+                } else {
+                    InnerObserver<?, ?>[] innerObserverArr3 = new InnerObserver[length - 1];
+                    System.arraycopy(innerObserverArr, 0, innerObserverArr3, 0, i);
+                    System.arraycopy(innerObserverArr, i + 1, innerObserverArr3, i, (length - i) - 1);
+                    innerObserverArr2 = innerObserverArr3;
+                }
+            } while (!this.j.compareAndSet(innerObserverArr, innerObserverArr2));
+        }
+
+        void c() {
+            if (getAndIncrement() == 0) {
+                d();
+            }
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        void d() {
+            int i;
+            boolean z;
+            Observer<? super U> observer = this.a;
+            int i2 = 1;
+            while (!a()) {
+                SimplePlainQueue<U> simplePlainQueue = this.f;
+                if (simplePlainQueue != null) {
+                    while (!a()) {
+                        U poll = simplePlainQueue.poll();
+                        if (poll != null) {
+                            observer.onNext(poll);
+                        } else if (poll == null) {
+                        }
+                    }
+                    return;
+                }
+                boolean z2 = this.g;
+                SimplePlainQueue<U> simplePlainQueue2 = this.f;
+                InnerObserver<?, ?>[] innerObserverArr = this.j.get();
+                int length = innerObserverArr.length;
+                if (this.d != Integer.MAX_VALUE) {
+                    synchronized (this) {
+                        i = this.o.size();
+                    }
+                } else {
+                    i = 0;
+                }
+                if (z2 && ((simplePlainQueue2 == null || simplePlainQueue2.isEmpty()) && length == 0 && i == 0)) {
+                    Throwable terminate = this.h.terminate();
+                    if (terminate != ExceptionHelper.a) {
+                        if (terminate == null) {
+                            observer.onComplete();
+                            return;
+                        } else {
+                            observer.onError(terminate);
+                            return;
+                        }
+                    }
+                    return;
+                }
+                if (length != 0) {
+                    long j = this.m;
+                    int i3 = this.n;
+                    if (length <= i3 || innerObserverArr[i3].a != j) {
+                        if (length <= i3) {
+                            i3 = 0;
+                        }
+                        int i4 = i3;
+                        for (int i5 = 0; i5 < length && innerObserverArr[i4].a != j; i5++) {
+                            i4++;
+                            if (i4 == length) {
+                                i4 = 0;
+                            }
+                        }
+                        this.n = i4;
+                        this.m = innerObserverArr[i4].a;
+                        i3 = i4;
+                    }
+                    int i6 = 0;
+                    z = false;
+                    while (i6 < length) {
+                        if (a()) {
+                            return;
+                        }
+                        InnerObserver<T, U> innerObserver = innerObserverArr[i3];
+                        while (!a()) {
+                            SimpleQueue<U> simpleQueue = innerObserver.d;
+                            if (simpleQueue != null) {
+                                do {
+                                    try {
+                                        U poll2 = simpleQueue.poll();
+                                        if (poll2 != null) {
+                                            observer.onNext(poll2);
+                                        } else if (poll2 == null) {
+                                        }
+                                    } catch (Throwable th) {
+                                        Exceptions.b(th);
+                                        innerObserver.a();
+                                        this.h.addThrowable(th);
+                                        if (a()) {
+                                            return;
+                                        }
+                                        b(innerObserver);
+                                        i6++;
+                                        z = true;
+                                    }
+                                } while (!a());
+                                return;
+                            }
+                            boolean z3 = innerObserver.c;
+                            SimpleQueue<U> simpleQueue2 = innerObserver.d;
+                            if (z3 && (simpleQueue2 == null || simpleQueue2.isEmpty())) {
+                                b(innerObserver);
+                                if (a()) {
+                                    return;
+                                } else {
+                                    z = true;
+                                }
+                            }
+                            i3++;
+                            if (i3 == length) {
+                                i3 = 0;
+                            }
+                            i6++;
+                        }
+                        return;
+                    }
+                    this.n = i3;
+                    this.m = innerObserverArr[i3].a;
+                } else {
+                    z = false;
+                }
+                if (!z) {
+                    i2 = addAndGet(-i2);
+                    if (i2 == 0) {
+                        return;
+                    }
+                } else if (this.d != Integer.MAX_VALUE) {
+                    synchronized (this) {
+                        ObservableSource<? extends U> poll3 = this.o.poll();
+                        if (poll3 == null) {
+                            this.p--;
+                        } else {
+                            a(poll3);
+                        }
+                    }
+                } else {
+                    continue;
+                }
+            }
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            Throwable terminate;
+            if (this.i) {
+                return;
+            }
+            this.i = true;
+            if (!b() || (terminate = this.h.terminate()) == null || terminate == ExceptionHelper.a) {
+                return;
+            }
+            RxJavaPlugins.b(terminate);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            if (this.g) {
+                return;
+            }
+            this.g = true;
+            c();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (this.g) {
+                RxJavaPlugins.b(th);
+            } else if (!this.h.addThrowable(th)) {
+                RxJavaPlugins.b(th);
+            } else {
+                this.g = true;
+                c();
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            if (this.g) {
+                return;
+            }
+            try {
+                ObservableSource<? extends U> apply = this.b.apply(t);
+                ObjectHelper.a(apply, "The mapper returned a null ObservableSource");
+                ObservableSource<? extends U> observableSource = apply;
+                if (this.d != Integer.MAX_VALUE) {
+                    synchronized (this) {
+                        if (this.p == this.d) {
+                            this.o.offer(observableSource);
+                            return;
+                        }
+                        this.p++;
+                    }
+                }
+                a(observableSource);
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                this.k.dispose();
+                onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.k, disposable)) {
+                this.k = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+
+        boolean b() {
+            InnerObserver<?, ?>[] andSet;
+            this.k.dispose();
+            InnerObserver<?, ?>[] innerObserverArr = this.j.get();
+            InnerObserver<?, ?>[] innerObserverArr2 = r;
+            if (innerObserverArr == innerObserverArr2 || (andSet = this.j.getAndSet(innerObserverArr2)) == r) {
+                return false;
+            }
+            for (InnerObserver<?, ?> innerObserver : andSet) {
+                innerObserver.a();
+            }
+            return true;
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        boolean a(InnerObserver<T, U> innerObserver) {
+            InnerObserver<?, ?>[] innerObserverArr;
+            InnerObserver[] innerObserverArr2;
+            do {
+                innerObserverArr = this.j.get();
+                if (innerObserverArr == r) {
+                    innerObserver.a();
+                    return false;
+                }
+                int length = innerObserverArr.length;
+                innerObserverArr2 = new InnerObserver[length + 1];
+                System.arraycopy(innerObserverArr, 0, innerObserverArr2, 0, length);
+                innerObserverArr2[length] = innerObserver;
+            } while (!this.j.compareAndSet(innerObserverArr, innerObserverArr2));
+            return true;
+        }
+
+        boolean a(Callable<? extends U> callable) {
+            try {
+                U call = callable.call();
+                if (call == null) {
+                    return true;
+                }
+                if (get() == 0 && compareAndSet(0, 1)) {
+                    this.a.onNext(call);
+                    if (decrementAndGet() == 0) {
+                        return true;
+                    }
+                } else {
+                    SimplePlainQueue<U> simplePlainQueue = this.f;
+                    if (simplePlainQueue == null) {
+                        int i = this.d;
+                        if (i == Integer.MAX_VALUE) {
+                            simplePlainQueue = new SpscLinkedArrayQueue<>(this.e);
+                        } else {
+                            simplePlainQueue = new SpscArrayQueue(i);
+                        }
+                        this.f = simplePlainQueue;
+                    }
+                    if (!simplePlainQueue.offer(call)) {
+                        onError(new IllegalStateException("Scalar queue full?!"));
+                        return true;
+                    }
+                    if (getAndIncrement() != 0) {
+                        return false;
+                    }
+                }
+                d();
+                return true;
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                this.h.addThrowable(th);
+                c();
+                return true;
+            }
+        }
+
+        void a(U u, InnerObserver<T, U> innerObserver) {
+            if (get() == 0 && compareAndSet(0, 1)) {
+                this.a.onNext(u);
+                if (decrementAndGet() == 0) {
+                    return;
+                }
+            } else {
+                SimpleQueue simpleQueue = innerObserver.d;
+                if (simpleQueue == null) {
+                    simpleQueue = new SpscLinkedArrayQueue(this.e);
+                    innerObserver.d = simpleQueue;
+                }
+                simpleQueue.offer(u);
+                if (getAndIncrement() != 0) {
+                    return;
+                }
+            }
+            d();
+        }
+
+        boolean a() {
+            if (this.i) {
+                return true;
+            }
+            Throwable th = this.h.get();
+            if (this.c || th == null) {
+                return false;
+            }
+            b();
+            Throwable terminate = this.h.terminate();
+            if (terminate != ExceptionHelper.a) {
+                this.a.onError(terminate);
+            }
+            return true;
+        }
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableFlatMapCompletable.java

@@ -0,0 +1,169 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.CompletableObserver;
+import io.reactivex.CompletableSource;
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.CompositeDisposable;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Function;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.observers.BasicIntQueueDisposable;
+import io.reactivex.internal.util.AtomicThrowable;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableFlatMapCompletable<T> extends AbstractObservableWithUpstream<T, T> {
+    final Function<? super T, ? extends CompletableSource> b;
+    final boolean c;
+
+    public ObservableFlatMapCompletable(ObservableSource<T> observableSource, Function<? super T, ? extends CompletableSource> function, boolean z) {
+        super(observableSource);
+        this.b = function;
+        this.c = z;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super T> observer) {
+        this.a.subscribe(new FlatMapCompletableMainObserver(observer, this.b, this.c));
+    }
+
+    static final class FlatMapCompletableMainObserver<T> extends BasicIntQueueDisposable<T> implements Observer<T> {
+        final Observer<? super T> a;
+        final Function<? super T, ? extends CompletableSource> c;
+        final boolean d;
+        Disposable f;
+        volatile boolean g;
+        final AtomicThrowable b = new AtomicThrowable();
+        final CompositeDisposable e = new CompositeDisposable();
+
+        final class InnerObserver extends AtomicReference<Disposable> implements CompletableObserver, Disposable {
+            InnerObserver() {
+            }
+
+            @Override // io.reactivex.disposables.Disposable
+            public void dispose() {
+                DisposableHelper.dispose(this);
+            }
+
+            @Override // io.reactivex.CompletableObserver, io.reactivex.MaybeObserver
+            public void onComplete() {
+                FlatMapCompletableMainObserver.this.a(this);
+            }
+
+            @Override // io.reactivex.CompletableObserver
+            public void onError(Throwable th) {
+                FlatMapCompletableMainObserver.this.a(this, th);
+            }
+
+            @Override // io.reactivex.CompletableObserver
+            public void onSubscribe(Disposable disposable) {
+                DisposableHelper.setOnce(this, disposable);
+            }
+        }
+
+        FlatMapCompletableMainObserver(Observer<? super T> observer, Function<? super T, ? extends CompletableSource> function, boolean z) {
+            this.a = observer;
+            this.c = function;
+            this.d = z;
+            lazySet(1);
+        }
+
+        void a(FlatMapCompletableMainObserver<T>.InnerObserver innerObserver) {
+            this.e.c(innerObserver);
+            onComplete();
+        }
+
+        @Override // io.reactivex.internal.fuseable.SimpleQueue
+        public void clear() {
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.g = true;
+            this.f.dispose();
+            this.e.dispose();
+        }
+
+        @Override // io.reactivex.internal.fuseable.SimpleQueue
+        public boolean isEmpty() {
+            return true;
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            if (decrementAndGet() == 0) {
+                Throwable terminate = this.b.terminate();
+                if (terminate != null) {
+                    this.a.onError(terminate);
+                } else {
+                    this.a.onComplete();
+                }
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (!this.b.addThrowable(th)) {
+                RxJavaPlugins.b(th);
+                return;
+            }
+            if (this.d) {
+                if (decrementAndGet() == 0) {
+                    this.a.onError(this.b.terminate());
+                    return;
+                }
+                return;
+            }
+            dispose();
+            if (getAndSet(0) > 0) {
+                this.a.onError(this.b.terminate());
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            try {
+                CompletableSource apply = this.c.apply(t);
+                ObjectHelper.a(apply, "The mapper returned a null CompletableSource");
+                CompletableSource completableSource = apply;
+                getAndIncrement();
+                InnerObserver innerObserver = new InnerObserver();
+                if (this.g || !this.e.b(innerObserver)) {
+                    return;
+                }
+                completableSource.a(innerObserver);
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                this.f.dispose();
+                onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.f, disposable)) {
+                this.f = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+
+        @Override // io.reactivex.internal.fuseable.SimpleQueue
+        public T poll() throws Exception {
+            return null;
+        }
+
+        @Override // io.reactivex.internal.fuseable.QueueFuseable
+        public int requestFusion(int i) {
+            return i & 2;
+        }
+
+        void a(FlatMapCompletableMainObserver<T>.InnerObserver innerObserver, Throwable th) {
+            this.e.c(innerObserver);
+            onError(th);
+        }
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableFlatMapCompletableCompletable.java

@@ -0,0 +1,159 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Completable;
+import io.reactivex.CompletableObserver;
+import io.reactivex.CompletableSource;
+import io.reactivex.Observable;
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.CompositeDisposable;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Function;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.fuseable.FuseToObservable;
+import io.reactivex.internal.util.AtomicThrowable;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableFlatMapCompletableCompletable<T> extends Completable implements FuseToObservable<T> {
+    final ObservableSource<T> a;
+    final Function<? super T, ? extends CompletableSource> b;
+    final boolean c;
+
+    public ObservableFlatMapCompletableCompletable(ObservableSource<T> observableSource, Function<? super T, ? extends CompletableSource> function, boolean z) {
+        this.a = observableSource;
+        this.b = function;
+        this.c = z;
+    }
+
+    @Override // io.reactivex.internal.fuseable.FuseToObservable
+    public Observable<T> a() {
+        return RxJavaPlugins.a(new ObservableFlatMapCompletable(this.a, this.b, this.c));
+    }
+
+    @Override // io.reactivex.Completable
+    protected void b(CompletableObserver completableObserver) {
+        this.a.subscribe(new FlatMapCompletableMainObserver(completableObserver, this.b, this.c));
+    }
+
+    static final class FlatMapCompletableMainObserver<T> extends AtomicInteger implements Disposable, Observer<T> {
+        final CompletableObserver a;
+        final Function<? super T, ? extends CompletableSource> c;
+        final boolean d;
+        Disposable f;
+        volatile boolean g;
+        final AtomicThrowable b = new AtomicThrowable();
+        final CompositeDisposable e = new CompositeDisposable();
+
+        final class InnerObserver extends AtomicReference<Disposable> implements CompletableObserver, Disposable {
+            InnerObserver() {
+            }
+
+            @Override // io.reactivex.disposables.Disposable
+            public void dispose() {
+                DisposableHelper.dispose(this);
+            }
+
+            @Override // io.reactivex.CompletableObserver, io.reactivex.MaybeObserver
+            public void onComplete() {
+                FlatMapCompletableMainObserver.this.a(this);
+            }
+
+            @Override // io.reactivex.CompletableObserver
+            public void onError(Throwable th) {
+                FlatMapCompletableMainObserver.this.a(this, th);
+            }
+
+            @Override // io.reactivex.CompletableObserver
+            public void onSubscribe(Disposable disposable) {
+                DisposableHelper.setOnce(this, disposable);
+            }
+        }
+
+        FlatMapCompletableMainObserver(CompletableObserver completableObserver, Function<? super T, ? extends CompletableSource> function, boolean z) {
+            this.a = completableObserver;
+            this.c = function;
+            this.d = z;
+            lazySet(1);
+        }
+
+        void a(FlatMapCompletableMainObserver<T>.InnerObserver innerObserver) {
+            this.e.c(innerObserver);
+            onComplete();
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.g = true;
+            this.f.dispose();
+            this.e.dispose();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            if (decrementAndGet() == 0) {
+                Throwable terminate = this.b.terminate();
+                if (terminate != null) {
+                    this.a.onError(terminate);
+                } else {
+                    this.a.onComplete();
+                }
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (!this.b.addThrowable(th)) {
+                RxJavaPlugins.b(th);
+                return;
+            }
+            if (this.d) {
+                if (decrementAndGet() == 0) {
+                    this.a.onError(this.b.terminate());
+                    return;
+                }
+                return;
+            }
+            dispose();
+            if (getAndSet(0) > 0) {
+                this.a.onError(this.b.terminate());
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            try {
+                CompletableSource apply = this.c.apply(t);
+                ObjectHelper.a(apply, "The mapper returned a null CompletableSource");
+                CompletableSource completableSource = apply;
+                getAndIncrement();
+                InnerObserver innerObserver = new InnerObserver();
+                if (this.g || !this.e.b(innerObserver)) {
+                    return;
+                }
+                completableSource.a(innerObserver);
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                this.f.dispose();
+                onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.f, disposable)) {
+                this.f = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+
+        void a(FlatMapCompletableMainObserver<T>.InnerObserver innerObserver, Throwable th) {
+            this.e.c(innerObserver);
+            onError(th);
+        }
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableFlatMapMaybe.java

@@ -0,0 +1,276 @@
+package io.reactivex.internal.operators.observable;
+
+import android.Manifest;
+import io.reactivex.MaybeObserver;
+import io.reactivex.MaybeSource;
+import io.reactivex.Observable;
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.CompositeDisposable;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Function;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.queue.SpscLinkedArrayQueue;
+import io.reactivex.internal.util.AtomicThrowable;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableFlatMapMaybe<T, R> extends AbstractObservableWithUpstream<T, R> {
+    final Function<? super T, ? extends MaybeSource<? extends R>> b;
+    final boolean c;
+
+    public ObservableFlatMapMaybe(ObservableSource<T> observableSource, Function<? super T, ? extends MaybeSource<? extends R>> function, boolean z) {
+        super(observableSource);
+        this.b = function;
+        this.c = z;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super R> observer) {
+        this.a.subscribe(new FlatMapMaybeObserver(observer, this.b, this.c));
+    }
+
+    static final class FlatMapMaybeObserver<T, R> extends AtomicInteger implements Observer<T>, Disposable {
+        final Observer<? super R> a;
+        final boolean b;
+        final Function<? super T, ? extends MaybeSource<? extends R>> f;
+        Disposable h;
+        volatile boolean i;
+        final CompositeDisposable c = new CompositeDisposable();
+        final AtomicThrowable e = new AtomicThrowable();
+        final AtomicInteger d = new AtomicInteger(1);
+        final AtomicReference<SpscLinkedArrayQueue<R>> g = new AtomicReference<>();
+
+        final class InnerObserver extends AtomicReference<Disposable> implements MaybeObserver<R>, Disposable {
+            InnerObserver() {
+            }
+
+            @Override // io.reactivex.disposables.Disposable
+            public void dispose() {
+                DisposableHelper.dispose(this);
+            }
+
+            @Override // io.reactivex.MaybeObserver
+            public void onComplete() {
+                FlatMapMaybeObserver.this.a(this);
+            }
+
+            @Override // io.reactivex.MaybeObserver
+            public void onError(Throwable th) {
+                FlatMapMaybeObserver.this.a(this, th);
+            }
+
+            @Override // io.reactivex.MaybeObserver
+            public void onSubscribe(Disposable disposable) {
+                DisposableHelper.setOnce(this, disposable);
+            }
+
+            @Override // io.reactivex.MaybeObserver
+            public void onSuccess(R r) {
+                FlatMapMaybeObserver.this.a((FlatMapMaybeObserver<T, InnerObserver>.InnerObserver) this, (InnerObserver) r);
+            }
+        }
+
+        FlatMapMaybeObserver(Observer<? super R> observer, Function<? super T, ? extends MaybeSource<? extends R>> function, boolean z) {
+            this.a = observer;
+            this.f = function;
+            this.b = z;
+        }
+
+        void a(FlatMapMaybeObserver<T, R>.InnerObserver innerObserver, R r) {
+            this.c.c(innerObserver);
+            if (get() == 0) {
+                if (compareAndSet(0, 1)) {
+                    this.a.onNext(r);
+                    boolean z = this.d.decrementAndGet() == 0;
+                    SpscLinkedArrayQueue<R> spscLinkedArrayQueue = this.g.get();
+                    if (!z || (spscLinkedArrayQueue != null && !spscLinkedArrayQueue.isEmpty())) {
+                        if (decrementAndGet() == 0) {
+                            return;
+                        }
+                        c();
+                    } else {
+                        Throwable terminate = this.e.terminate();
+                        if (terminate != null) {
+                            this.a.onError(terminate);
+                            return;
+                        } else {
+                            this.a.onComplete();
+                            return;
+                        }
+                    }
+                }
+            }
+            SpscLinkedArrayQueue<R> d = d();
+            synchronized (d) {
+                d.offer(r);
+            }
+            this.d.decrementAndGet();
+            if (getAndIncrement() != 0) {
+                return;
+            }
+            c();
+        }
+
+        void b() {
+            if (getAndIncrement() == 0) {
+                c();
+            }
+        }
+
+        void c() {
+            Observer<? super R> observer = this.a;
+            AtomicInteger atomicInteger = this.d;
+            AtomicReference<SpscLinkedArrayQueue<R>> atomicReference = this.g;
+            int i = 1;
+            while (!this.i) {
+                if (!this.b && this.e.get() != null) {
+                    Throwable terminate = this.e.terminate();
+                    a();
+                    observer.onError(terminate);
+                    return;
+                }
+                boolean z = atomicInteger.get() == 0;
+                SpscLinkedArrayQueue<R> spscLinkedArrayQueue = atomicReference.get();
+                Manifest poll = spscLinkedArrayQueue != null ? spscLinkedArrayQueue.poll() : null;
+                boolean z2 = poll == null;
+                if (z && z2) {
+                    Throwable terminate2 = this.e.terminate();
+                    if (terminate2 != null) {
+                        observer.onError(terminate2);
+                        return;
+                    } else {
+                        observer.onComplete();
+                        return;
+                    }
+                }
+                if (z2) {
+                    i = addAndGet(-i);
+                    if (i == 0) {
+                        return;
+                    }
+                } else {
+                    observer.onNext(poll);
+                }
+            }
+            a();
+        }
+
+        SpscLinkedArrayQueue<R> d() {
+            SpscLinkedArrayQueue<R> spscLinkedArrayQueue;
+            do {
+                SpscLinkedArrayQueue<R> spscLinkedArrayQueue2 = this.g.get();
+                if (spscLinkedArrayQueue2 != null) {
+                    return spscLinkedArrayQueue2;
+                }
+                spscLinkedArrayQueue = new SpscLinkedArrayQueue<>(Observable.bufferSize());
+            } while (!this.g.compareAndSet(null, spscLinkedArrayQueue));
+            return spscLinkedArrayQueue;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.i = true;
+            this.h.dispose();
+            this.c.dispose();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.d.decrementAndGet();
+            b();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            this.d.decrementAndGet();
+            if (!this.e.addThrowable(th)) {
+                RxJavaPlugins.b(th);
+                return;
+            }
+            if (!this.b) {
+                this.c.dispose();
+            }
+            b();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            try {
+                MaybeSource<? extends R> apply = this.f.apply(t);
+                ObjectHelper.a(apply, "The mapper returned a null MaybeSource");
+                MaybeSource<? extends R> maybeSource = apply;
+                this.d.getAndIncrement();
+                InnerObserver innerObserver = new InnerObserver();
+                if (this.i || !this.c.b(innerObserver)) {
+                    return;
+                }
+                maybeSource.a(innerObserver);
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                this.h.dispose();
+                onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.h, disposable)) {
+                this.h = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+
+        void a(FlatMapMaybeObserver<T, R>.InnerObserver innerObserver, Throwable th) {
+            this.c.c(innerObserver);
+            if (this.e.addThrowable(th)) {
+                if (!this.b) {
+                    this.h.dispose();
+                    this.c.dispose();
+                }
+                this.d.decrementAndGet();
+                b();
+                return;
+            }
+            RxJavaPlugins.b(th);
+        }
+
+        void a(FlatMapMaybeObserver<T, R>.InnerObserver innerObserver) {
+            this.c.c(innerObserver);
+            if (get() == 0) {
+                if (compareAndSet(0, 1)) {
+                    boolean z = this.d.decrementAndGet() == 0;
+                    SpscLinkedArrayQueue<R> spscLinkedArrayQueue = this.g.get();
+                    if (z && (spscLinkedArrayQueue == null || spscLinkedArrayQueue.isEmpty())) {
+                        Throwable terminate = this.e.terminate();
+                        if (terminate != null) {
+                            this.a.onError(terminate);
+                            return;
+                        } else {
+                            this.a.onComplete();
+                            return;
+                        }
+                    }
+                    if (decrementAndGet() == 0) {
+                        return;
+                    }
+                    c();
+                    return;
+                }
+            }
+            this.d.decrementAndGet();
+            b();
+        }
+
+        void a() {
+            SpscLinkedArrayQueue<R> spscLinkedArrayQueue = this.g.get();
+            if (spscLinkedArrayQueue != null) {
+                spscLinkedArrayQueue.clear();
+            }
+        }
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableFlatMapSingle.java

@@ -0,0 +1,244 @@
+package io.reactivex.internal.operators.observable;
+
+import android.Manifest;
+import io.reactivex.Observable;
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.SingleObserver;
+import io.reactivex.SingleSource;
+import io.reactivex.disposables.CompositeDisposable;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Function;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.queue.SpscLinkedArrayQueue;
+import io.reactivex.internal.util.AtomicThrowable;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableFlatMapSingle<T, R> extends AbstractObservableWithUpstream<T, R> {
+    final Function<? super T, ? extends SingleSource<? extends R>> b;
+    final boolean c;
+
+    public ObservableFlatMapSingle(ObservableSource<T> observableSource, Function<? super T, ? extends SingleSource<? extends R>> function, boolean z) {
+        super(observableSource);
+        this.b = function;
+        this.c = z;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super R> observer) {
+        this.a.subscribe(new FlatMapSingleObserver(observer, this.b, this.c));
+    }
+
+    static final class FlatMapSingleObserver<T, R> extends AtomicInteger implements Observer<T>, Disposable {
+        final Observer<? super R> a;
+        final boolean b;
+        final Function<? super T, ? extends SingleSource<? extends R>> f;
+        Disposable h;
+        volatile boolean i;
+        final CompositeDisposable c = new CompositeDisposable();
+        final AtomicThrowable e = new AtomicThrowable();
+        final AtomicInteger d = new AtomicInteger(1);
+        final AtomicReference<SpscLinkedArrayQueue<R>> g = new AtomicReference<>();
+
+        final class InnerObserver extends AtomicReference<Disposable> implements SingleObserver<R>, Disposable {
+            InnerObserver() {
+            }
+
+            @Override // io.reactivex.disposables.Disposable
+            public void dispose() {
+                DisposableHelper.dispose(this);
+            }
+
+            @Override // io.reactivex.SingleObserver
+            public void onError(Throwable th) {
+                FlatMapSingleObserver.this.a(this, th);
+            }
+
+            @Override // io.reactivex.SingleObserver
+            public void onSubscribe(Disposable disposable) {
+                DisposableHelper.setOnce(this, disposable);
+            }
+
+            @Override // io.reactivex.SingleObserver
+            public void onSuccess(R r) {
+                FlatMapSingleObserver.this.a((FlatMapSingleObserver<T, InnerObserver>.InnerObserver) this, (InnerObserver) r);
+            }
+        }
+
+        FlatMapSingleObserver(Observer<? super R> observer, Function<? super T, ? extends SingleSource<? extends R>> function, boolean z) {
+            this.a = observer;
+            this.f = function;
+            this.b = z;
+        }
+
+        void a(FlatMapSingleObserver<T, R>.InnerObserver innerObserver, R r) {
+            this.c.c(innerObserver);
+            if (get() == 0) {
+                if (compareAndSet(0, 1)) {
+                    this.a.onNext(r);
+                    boolean z = this.d.decrementAndGet() == 0;
+                    SpscLinkedArrayQueue<R> spscLinkedArrayQueue = this.g.get();
+                    if (!z || (spscLinkedArrayQueue != null && !spscLinkedArrayQueue.isEmpty())) {
+                        if (decrementAndGet() == 0) {
+                            return;
+                        }
+                        c();
+                    } else {
+                        Throwable terminate = this.e.terminate();
+                        if (terminate != null) {
+                            this.a.onError(terminate);
+                            return;
+                        } else {
+                            this.a.onComplete();
+                            return;
+                        }
+                    }
+                }
+            }
+            SpscLinkedArrayQueue<R> d = d();
+            synchronized (d) {
+                d.offer(r);
+            }
+            this.d.decrementAndGet();
+            if (getAndIncrement() != 0) {
+                return;
+            }
+            c();
+        }
+
+        void b() {
+            if (getAndIncrement() == 0) {
+                c();
+            }
+        }
+
+        void c() {
+            Observer<? super R> observer = this.a;
+            AtomicInteger atomicInteger = this.d;
+            AtomicReference<SpscLinkedArrayQueue<R>> atomicReference = this.g;
+            int i = 1;
+            while (!this.i) {
+                if (!this.b && this.e.get() != null) {
+                    Throwable terminate = this.e.terminate();
+                    a();
+                    observer.onError(terminate);
+                    return;
+                }
+                boolean z = atomicInteger.get() == 0;
+                SpscLinkedArrayQueue<R> spscLinkedArrayQueue = atomicReference.get();
+                Manifest poll = spscLinkedArrayQueue != null ? spscLinkedArrayQueue.poll() : null;
+                boolean z2 = poll == null;
+                if (z && z2) {
+                    Throwable terminate2 = this.e.terminate();
+                    if (terminate2 != null) {
+                        observer.onError(terminate2);
+                        return;
+                    } else {
+                        observer.onComplete();
+                        return;
+                    }
+                }
+                if (z2) {
+                    i = addAndGet(-i);
+                    if (i == 0) {
+                        return;
+                    }
+                } else {
+                    observer.onNext(poll);
+                }
+            }
+            a();
+        }
+
+        SpscLinkedArrayQueue<R> d() {
+            SpscLinkedArrayQueue<R> spscLinkedArrayQueue;
+            do {
+                SpscLinkedArrayQueue<R> spscLinkedArrayQueue2 = this.g.get();
+                if (spscLinkedArrayQueue2 != null) {
+                    return spscLinkedArrayQueue2;
+                }
+                spscLinkedArrayQueue = new SpscLinkedArrayQueue<>(Observable.bufferSize());
+            } while (!this.g.compareAndSet(null, spscLinkedArrayQueue));
+            return spscLinkedArrayQueue;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.i = true;
+            this.h.dispose();
+            this.c.dispose();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.d.decrementAndGet();
+            b();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            this.d.decrementAndGet();
+            if (!this.e.addThrowable(th)) {
+                RxJavaPlugins.b(th);
+                return;
+            }
+            if (!this.b) {
+                this.c.dispose();
+            }
+            b();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            try {
+                SingleSource<? extends R> apply = this.f.apply(t);
+                ObjectHelper.a(apply, "The mapper returned a null SingleSource");
+                SingleSource<? extends R> singleSource = apply;
+                this.d.getAndIncrement();
+                InnerObserver innerObserver = new InnerObserver();
+                if (this.i || !this.c.b(innerObserver)) {
+                    return;
+                }
+                singleSource.a(innerObserver);
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                this.h.dispose();
+                onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.h, disposable)) {
+                this.h = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+
+        void a(FlatMapSingleObserver<T, R>.InnerObserver innerObserver, Throwable th) {
+            this.c.c(innerObserver);
+            if (this.e.addThrowable(th)) {
+                if (!this.b) {
+                    this.h.dispose();
+                    this.c.dispose();
+                }
+                this.d.decrementAndGet();
+                b();
+                return;
+            }
+            RxJavaPlugins.b(th);
+        }
+
+        void a() {
+            SpscLinkedArrayQueue<R> spscLinkedArrayQueue = this.g.get();
+            if (spscLinkedArrayQueue != null) {
+                spscLinkedArrayQueue.clear();
+            }
+        }
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableFlattenIterable.java

@@ -0,0 +1,105 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Function;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.plugins.RxJavaPlugins;
+
+/* loaded from: classes2.dex */
+public final class ObservableFlattenIterable<T, R> extends AbstractObservableWithUpstream<T, R> {
+    final Function<? super T, ? extends Iterable<? extends R>> b;
+
+    static final class FlattenIterableObserver<T, R> implements Observer<T>, Disposable {
+        final Observer<? super R> a;
+        final Function<? super T, ? extends Iterable<? extends R>> b;
+        Disposable c;
+
+        FlattenIterableObserver(Observer<? super R> observer, Function<? super T, ? extends Iterable<? extends R>> function) {
+            this.a = observer;
+            this.b = function;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.c.dispose();
+            this.c = DisposableHelper.DISPOSED;
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            Disposable disposable = this.c;
+            DisposableHelper disposableHelper = DisposableHelper.DISPOSED;
+            if (disposable == disposableHelper) {
+                return;
+            }
+            this.c = disposableHelper;
+            this.a.onComplete();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            Disposable disposable = this.c;
+            DisposableHelper disposableHelper = DisposableHelper.DISPOSED;
+            if (disposable == disposableHelper) {
+                RxJavaPlugins.b(th);
+            } else {
+                this.c = disposableHelper;
+                this.a.onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            if (this.c == DisposableHelper.DISPOSED) {
+                return;
+            }
+            try {
+                Observer<? super R> observer = this.a;
+                for (R r : this.b.apply(t)) {
+                    try {
+                        try {
+                            ObjectHelper.a(r, "The iterator returned a null value");
+                            observer.onNext(r);
+                        } catch (Throwable th) {
+                            Exceptions.b(th);
+                            this.c.dispose();
+                            onError(th);
+                            return;
+                        }
+                    } catch (Throwable th2) {
+                        Exceptions.b(th2);
+                        this.c.dispose();
+                        onError(th2);
+                        return;
+                    }
+                }
+            } catch (Throwable th3) {
+                Exceptions.b(th3);
+                this.c.dispose();
+                onError(th3);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.c, disposable)) {
+                this.c = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+    }
+
+    public ObservableFlattenIterable(ObservableSource<T> observableSource, Function<? super T, ? extends Iterable<? extends R>> function) {
+        super(observableSource);
+        this.b = function;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super R> observer) {
+        this.a.subscribe(new FlattenIterableObserver(observer, this.b));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableFromArray.java

@@ -0,0 +1,96 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.observers.BasicQueueDisposable;
+
+/* loaded from: classes2.dex */
+public final class ObservableFromArray<T> extends Observable<T> {
+    final T[] a;
+
+    static final class FromArrayDisposable<T> extends BasicQueueDisposable<T> {
+        final Observer<? super T> a;
+        final T[] b;
+        int c;
+        boolean d;
+        volatile boolean e;
+
+        FromArrayDisposable(Observer<? super T> observer, T[] tArr) {
+            this.a = observer;
+            this.b = tArr;
+        }
+
+        public boolean a() {
+            return this.e;
+        }
+
+        void b() {
+            T[] tArr = this.b;
+            int length = tArr.length;
+            for (int i = 0; i < length && !a(); i++) {
+                T t = tArr[i];
+                if (t == null) {
+                    this.a.onError(new NullPointerException("The " + i + "th element is null"));
+                    return;
+                }
+                this.a.onNext(t);
+            }
+            if (a()) {
+                return;
+            }
+            this.a.onComplete();
+        }
+
+        @Override // io.reactivex.internal.fuseable.SimpleQueue
+        public void clear() {
+            this.c = this.b.length;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.e = true;
+        }
+
+        @Override // io.reactivex.internal.fuseable.SimpleQueue
+        public boolean isEmpty() {
+            return this.c == this.b.length;
+        }
+
+        @Override // io.reactivex.internal.fuseable.SimpleQueue
+        public T poll() {
+            int i = this.c;
+            T[] tArr = this.b;
+            if (i == tArr.length) {
+                return null;
+            }
+            this.c = i + 1;
+            T t = tArr[i];
+            ObjectHelper.a((Object) t, "The array element is null");
+            return t;
+        }
+
+        @Override // io.reactivex.internal.fuseable.QueueFuseable
+        public int requestFusion(int i) {
+            if ((i & 1) == 0) {
+                return 0;
+            }
+            this.d = true;
+            return 1;
+        }
+    }
+
+    public ObservableFromArray(T[] tArr) {
+        this.a = tArr;
+    }
+
+    @Override // io.reactivex.Observable
+    public void subscribeActual(Observer<? super T> observer) {
+        FromArrayDisposable fromArrayDisposable = new FromArrayDisposable(observer, this.a);
+        observer.onSubscribe(fromArrayDisposable);
+        if (fromArrayDisposable.d) {
+            return;
+        }
+        fromArrayDisposable.b();
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableFromCallable.java

@@ -0,0 +1,46 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.observers.DeferredScalarDisposable;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.Callable;
+
+/* loaded from: classes2.dex */
+public final class ObservableFromCallable<T> extends Observable<T> implements Callable<T> {
+    final Callable<? extends T> a;
+
+    public ObservableFromCallable(Callable<? extends T> callable) {
+        this.a = callable;
+    }
+
+    @Override // java.util.concurrent.Callable
+    public T call() throws Exception {
+        T call = this.a.call();
+        ObjectHelper.a((Object) call, "The callable returned a null value");
+        return call;
+    }
+
+    @Override // io.reactivex.Observable
+    public void subscribeActual(Observer<? super T> observer) {
+        DeferredScalarDisposable deferredScalarDisposable = new DeferredScalarDisposable(observer);
+        observer.onSubscribe(deferredScalarDisposable);
+        if (deferredScalarDisposable.isDisposed()) {
+            return;
+        }
+        try {
+            T call = this.a.call();
+            ObjectHelper.a((Object) call, "Callable returned null");
+            deferredScalarDisposable.complete(call);
+        } catch (Throwable th) {
+            Exceptions.b(th);
+            if (deferredScalarDisposable.isDisposed()) {
+                RxJavaPlugins.b(th);
+            } else {
+                observer.onError(th);
+            }
+        }
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableFromFuture.java

@@ -0,0 +1,42 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.observers.DeferredScalarDisposable;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes2.dex */
+public final class ObservableFromFuture<T> extends Observable<T> {
+    final Future<? extends T> a;
+    final long b;
+    final TimeUnit c;
+
+    public ObservableFromFuture(Future<? extends T> future, long j, TimeUnit timeUnit) {
+        this.a = future;
+        this.b = j;
+        this.c = timeUnit;
+    }
+
+    @Override // io.reactivex.Observable
+    public void subscribeActual(Observer<? super T> observer) {
+        DeferredScalarDisposable deferredScalarDisposable = new DeferredScalarDisposable(observer);
+        observer.onSubscribe(deferredScalarDisposable);
+        if (deferredScalarDisposable.isDisposed()) {
+            return;
+        }
+        try {
+            T t = this.c != null ? this.a.get(this.b, this.c) : this.a.get();
+            ObjectHelper.a((Object) t, "Future returned null");
+            deferredScalarDisposable.complete(t);
+        } catch (Throwable th) {
+            Exceptions.b(th);
+            if (deferredScalarDisposable.isDisposed()) {
+                return;
+            }
+            observer.onError(th);
+        }
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableFromIterable.java

@@ -0,0 +1,131 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.internal.disposables.EmptyDisposable;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.observers.BasicQueueDisposable;
+import java.util.Iterator;
+
+/* loaded from: classes2.dex */
+public final class ObservableFromIterable<T> extends Observable<T> {
+    final Iterable<? extends T> a;
+
+    static final class FromIterableDisposable<T> extends BasicQueueDisposable<T> {
+        final Observer<? super T> a;
+        final Iterator<? extends T> b;
+        volatile boolean c;
+        boolean d;
+        boolean e;
+        boolean f;
+
+        FromIterableDisposable(Observer<? super T> observer, Iterator<? extends T> it) {
+            this.a = observer;
+            this.b = it;
+        }
+
+        public boolean a() {
+            return this.c;
+        }
+
+        void b() {
+            while (!a()) {
+                try {
+                    T next = this.b.next();
+                    ObjectHelper.a((Object) next, "The iterator returned a null value");
+                    this.a.onNext(next);
+                    if (a()) {
+                        return;
+                    }
+                    try {
+                        if (!this.b.hasNext()) {
+                            if (a()) {
+                                return;
+                            }
+                            this.a.onComplete();
+                            return;
+                        }
+                    } catch (Throwable th) {
+                        Exceptions.b(th);
+                        this.a.onError(th);
+                        return;
+                    }
+                } catch (Throwable th2) {
+                    Exceptions.b(th2);
+                    this.a.onError(th2);
+                    return;
+                }
+            }
+        }
+
+        @Override // io.reactivex.internal.fuseable.SimpleQueue
+        public void clear() {
+            this.e = true;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.c = true;
+        }
+
+        @Override // io.reactivex.internal.fuseable.SimpleQueue
+        public boolean isEmpty() {
+            return this.e;
+        }
+
+        @Override // io.reactivex.internal.fuseable.SimpleQueue
+        public T poll() {
+            if (this.e) {
+                return null;
+            }
+            if (!this.f) {
+                this.f = true;
+            } else if (!this.b.hasNext()) {
+                this.e = true;
+                return null;
+            }
+            T next = this.b.next();
+            ObjectHelper.a((Object) next, "The iterator returned a null value");
+            return next;
+        }
+
+        @Override // io.reactivex.internal.fuseable.QueueFuseable
+        public int requestFusion(int i) {
+            if ((i & 1) == 0) {
+                return 0;
+            }
+            this.d = true;
+            return 1;
+        }
+    }
+
+    public ObservableFromIterable(Iterable<? extends T> iterable) {
+        this.a = iterable;
+    }
+
+    @Override // io.reactivex.Observable
+    public void subscribeActual(Observer<? super T> observer) {
+        try {
+            Iterator<? extends T> it = this.a.iterator();
+            try {
+                if (!it.hasNext()) {
+                    EmptyDisposable.complete(observer);
+                    return;
+                }
+                FromIterableDisposable fromIterableDisposable = new FromIterableDisposable(observer, it);
+                observer.onSubscribe(fromIterableDisposable);
+                if (fromIterableDisposable.d) {
+                    return;
+                }
+                fromIterableDisposable.b();
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                EmptyDisposable.error(th, observer);
+            }
+        } catch (Throwable th2) {
+            Exceptions.b(th2);
+            EmptyDisposable.error(th2, observer);
+        }
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableFromPublisher.java

@@ -0,0 +1,62 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.FlowableSubscriber;
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.subscriptions.SubscriptionHelper;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscription;
+
+/* loaded from: classes2.dex */
+public final class ObservableFromPublisher<T> extends Observable<T> {
+    final Publisher<? extends T> a;
+
+    static final class PublisherSubscriber<T> implements FlowableSubscriber<T>, Disposable {
+        final Observer<? super T> a;
+        Subscription b;
+
+        PublisherSubscriber(Observer<? super T> observer) {
+            this.a = observer;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.b.cancel();
+            this.b = SubscriptionHelper.CANCELLED;
+        }
+
+        @Override // org.reactivestreams.Subscriber
+        public void onComplete() {
+            this.a.onComplete();
+        }
+
+        @Override // org.reactivestreams.Subscriber
+        public void onError(Throwable th) {
+            this.a.onError(th);
+        }
+
+        @Override // org.reactivestreams.Subscriber
+        public void onNext(T t) {
+            this.a.onNext(t);
+        }
+
+        @Override // org.reactivestreams.Subscriber
+        public void onSubscribe(Subscription subscription) {
+            if (SubscriptionHelper.validate(this.b, subscription)) {
+                this.b = subscription;
+                this.a.onSubscribe(this);
+                subscription.request(Long.MAX_VALUE);
+            }
+        }
+    }
+
+    public ObservableFromPublisher(Publisher<? extends T> publisher) {
+        this.a = publisher;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super T> observer) {
+        this.a.a(new PublisherSubscriber(observer));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableFromUnsafeSource.java

@@ -0,0 +1,19 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Observable;
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+
+/* loaded from: classes2.dex */
+public final class ObservableFromUnsafeSource<T> extends Observable<T> {
+    final ObservableSource<T> a;
+
+    public ObservableFromUnsafeSource(ObservableSource<T> observableSource) {
+        this.a = observableSource;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super T> observer) {
+        this.a.subscribe(observer);
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableGenerate.java

@@ -0,0 +1,110 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Emitter;
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.BiFunction;
+import io.reactivex.functions.Consumer;
+import io.reactivex.internal.disposables.EmptyDisposable;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.Callable;
+
+/* loaded from: classes2.dex */
+public final class ObservableGenerate<T, S> extends Observable<T> {
+    final Callable<S> a;
+    final BiFunction<S, Emitter<T>, S> b;
+    final Consumer<? super S> c;
+
+    public ObservableGenerate(Callable<S> callable, BiFunction<S, Emitter<T>, S> biFunction, Consumer<? super S> consumer) {
+        this.a = callable;
+        this.b = biFunction;
+        this.c = consumer;
+    }
+
+    @Override // io.reactivex.Observable
+    public void subscribeActual(Observer<? super T> observer) {
+        try {
+            GeneratorDisposable generatorDisposable = new GeneratorDisposable(observer, this.b, this.c, this.a.call());
+            observer.onSubscribe(generatorDisposable);
+            generatorDisposable.a();
+        } catch (Throwable th) {
+            Exceptions.b(th);
+            EmptyDisposable.error(th, observer);
+        }
+    }
+
+    static final class GeneratorDisposable<T, S> implements Emitter<T>, Disposable {
+        final Observer<? super T> a;
+        final BiFunction<S, ? super Emitter<T>, S> b;
+        final Consumer<? super S> c;
+        S d;
+        volatile boolean e;
+        boolean f;
+
+        GeneratorDisposable(Observer<? super T> observer, BiFunction<S, ? super Emitter<T>, S> biFunction, Consumer<? super S> consumer, S s) {
+            this.a = observer;
+            this.b = biFunction;
+            this.c = consumer;
+            this.d = s;
+        }
+
+        public void a() {
+            S s = this.d;
+            if (this.e) {
+                this.d = null;
+                a(s);
+                return;
+            }
+            BiFunction<S, ? super Emitter<T>, S> biFunction = this.b;
+            while (!this.e) {
+                try {
+                    s = biFunction.apply(s, this);
+                    if (this.f) {
+                        this.e = true;
+                        this.d = null;
+                        a(s);
+                        return;
+                    }
+                } catch (Throwable th) {
+                    Exceptions.b(th);
+                    this.d = null;
+                    this.e = true;
+                    onError(th);
+                    a(s);
+                    return;
+                }
+            }
+            this.d = null;
+            a(s);
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.e = true;
+        }
+
+        @Override // io.reactivex.Emitter
+        public void onError(Throwable th) {
+            if (this.f) {
+                RxJavaPlugins.b(th);
+                return;
+            }
+            if (th == null) {
+                th = new NullPointerException("onError called with null. Null values are generally not allowed in 2.x operators and sources.");
+            }
+            this.f = true;
+            this.a.onError(th);
+        }
+
+        private void a(S s) {
+            try {
+                this.c.accept(s);
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                RxJavaPlugins.b(th);
+            }
+        }
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableGroupBy.java

@@ -0,0 +1,304 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Function;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.disposables.EmptyDisposable;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.queue.SpscLinkedArrayQueue;
+import io.reactivex.observables.GroupedObservable;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableGroupBy<T, K, V> extends AbstractObservableWithUpstream<T, GroupedObservable<K, V>> {
+    final Function<? super T, ? extends K> b;
+    final Function<? super T, ? extends V> c;
+    final int d;
+    final boolean e;
+
+    public static final class GroupByObserver<T, K, V> extends AtomicInteger implements Observer<T>, Disposable {
+        static final Object NULL_KEY = new Object();
+        private static final long serialVersionUID = -3688291656102519502L;
+        final int bufferSize;
+        final boolean delayError;
+        final Observer<? super GroupedObservable<K, V>> downstream;
+        final Function<? super T, ? extends K> keySelector;
+        Disposable upstream;
+        final Function<? super T, ? extends V> valueSelector;
+        final AtomicBoolean cancelled = new AtomicBoolean();
+        final Map<Object, GroupedUnicast<K, V>> groups = new ConcurrentHashMap();
+
+        public GroupByObserver(Observer<? super GroupedObservable<K, V>> observer, Function<? super T, ? extends K> function, Function<? super T, ? extends V> function2, int i, boolean z) {
+            this.downstream = observer;
+            this.keySelector = function;
+            this.valueSelector = function2;
+            this.bufferSize = i;
+            this.delayError = z;
+            lazySet(1);
+        }
+
+        public void cancel(K k) {
+            if (k == null) {
+                k = (K) NULL_KEY;
+            }
+            this.groups.remove(k);
+            if (decrementAndGet() == 0) {
+                this.upstream.dispose();
+            }
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            if (this.cancelled.compareAndSet(false, true) && decrementAndGet() == 0) {
+                this.upstream.dispose();
+            }
+        }
+
+        public boolean isDisposed() {
+            return this.cancelled.get();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            ArrayList arrayList = new ArrayList(this.groups.values());
+            this.groups.clear();
+            Iterator it = arrayList.iterator();
+            while (it.hasNext()) {
+                ((GroupedUnicast) it.next()).onComplete();
+            }
+            this.downstream.onComplete();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            ArrayList arrayList = new ArrayList(this.groups.values());
+            this.groups.clear();
+            Iterator it = arrayList.iterator();
+            while (it.hasNext()) {
+                ((GroupedUnicast) it.next()).onError(th);
+            }
+            this.downstream.onError(th);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            try {
+                K apply = this.keySelector.apply(t);
+                Object obj = apply != null ? apply : NULL_KEY;
+                GroupedUnicast<K, V> groupedUnicast = this.groups.get(obj);
+                if (groupedUnicast == null) {
+                    if (this.cancelled.get()) {
+                        return;
+                    }
+                    groupedUnicast = GroupedUnicast.a(apply, this.bufferSize, this, this.delayError);
+                    this.groups.put(obj, groupedUnicast);
+                    getAndIncrement();
+                    this.downstream.onNext(groupedUnicast);
+                }
+                try {
+                    V apply2 = this.valueSelector.apply(t);
+                    ObjectHelper.a(apply2, "The value supplied is null");
+                    groupedUnicast.onNext(apply2);
+                } catch (Throwable th) {
+                    Exceptions.b(th);
+                    this.upstream.dispose();
+                    onError(th);
+                }
+            } catch (Throwable th2) {
+                Exceptions.b(th2);
+                this.upstream.dispose();
+                onError(th2);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.upstream, disposable)) {
+                this.upstream = disposable;
+                this.downstream.onSubscribe(this);
+            }
+        }
+    }
+
+    static final class GroupedUnicast<K, T> extends GroupedObservable<K, T> {
+        final State<T, K> a;
+
+        protected GroupedUnicast(K k, State<T, K> state) {
+            super(k);
+            this.a = state;
+        }
+
+        public static <T, K> GroupedUnicast<K, T> a(K k, int i, GroupByObserver<?, K, T> groupByObserver, boolean z) {
+            return new GroupedUnicast<>(k, new State(i, groupByObserver, k, z));
+        }
+
+        public void onComplete() {
+            this.a.b();
+        }
+
+        public void onError(Throwable th) {
+            this.a.a(th);
+        }
+
+        public void onNext(T t) {
+            this.a.a((State<T, K>) t);
+        }
+
+        @Override // io.reactivex.Observable
+        protected void subscribeActual(Observer<? super T> observer) {
+            this.a.subscribe(observer);
+        }
+    }
+
+    public ObservableGroupBy(ObservableSource<T> observableSource, Function<? super T, ? extends K> function, Function<? super T, ? extends V> function2, int i, boolean z) {
+        super(observableSource);
+        this.b = function;
+        this.c = function2;
+        this.d = i;
+        this.e = z;
+    }
+
+    @Override // io.reactivex.Observable
+    public void subscribeActual(Observer<? super GroupedObservable<K, V>> observer) {
+        this.a.subscribe(new GroupByObserver(observer, this.b, this.c, this.d, this.e));
+    }
+
+    static final class State<T, K> extends AtomicInteger implements Disposable, ObservableSource<T> {
+        final K a;
+        final SpscLinkedArrayQueue<T> b;
+        final GroupByObserver<?, K, T> c;
+        final boolean d;
+        volatile boolean e;
+        Throwable f;
+        final AtomicBoolean g = new AtomicBoolean();
+        final AtomicBoolean h = new AtomicBoolean();
+        final AtomicReference<Observer<? super T>> i = new AtomicReference<>();
+
+        State(int i, GroupByObserver<?, K, T> groupByObserver, K k, boolean z) {
+            this.b = new SpscLinkedArrayQueue<>(i);
+            this.c = groupByObserver;
+            this.a = k;
+            this.d = z;
+        }
+
+        public void a(T t) {
+            this.b.offer(t);
+            a();
+        }
+
+        public void b() {
+            this.e = true;
+            a();
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            if (this.g.compareAndSet(false, true) && getAndIncrement() == 0) {
+                this.i.lazySet(null);
+                this.c.cancel(this.a);
+            }
+        }
+
+        @Override // io.reactivex.ObservableSource
+        public void subscribe(Observer<? super T> observer) {
+            if (!this.h.compareAndSet(false, true)) {
+                EmptyDisposable.error(new IllegalStateException("Only one Observer allowed!"), observer);
+                return;
+            }
+            observer.onSubscribe(this);
+            this.i.lazySet(observer);
+            if (this.g.get()) {
+                this.i.lazySet(null);
+            } else {
+                a();
+            }
+        }
+
+        public void a(Throwable th) {
+            this.f = th;
+            this.e = true;
+            a();
+        }
+
+        void a() {
+            if (getAndIncrement() != 0) {
+                return;
+            }
+            SpscLinkedArrayQueue<T> spscLinkedArrayQueue = this.b;
+            boolean z = this.d;
+            Observer<? super T> observer = this.i.get();
+            int i = 1;
+            while (true) {
+                if (observer != null) {
+                    while (true) {
+                        boolean z2 = this.e;
+                        T poll = spscLinkedArrayQueue.poll();
+                        boolean z3 = poll == null;
+                        if (a(z2, z3, observer, z)) {
+                            return;
+                        }
+                        if (z3) {
+                            break;
+                        } else {
+                            observer.onNext(poll);
+                        }
+                    }
+                }
+                i = addAndGet(-i);
+                if (i == 0) {
+                    return;
+                }
+                if (observer == null) {
+                    observer = this.i.get();
+                }
+            }
+        }
+
+        boolean a(boolean z, boolean z2, Observer<? super T> observer, boolean z3) {
+            if (this.g.get()) {
+                this.b.clear();
+                this.c.cancel(this.a);
+                this.i.lazySet(null);
+                return true;
+            }
+            if (!z) {
+                return false;
+            }
+            if (z3) {
+                if (!z2) {
+                    return false;
+                }
+                Throwable th = this.f;
+                this.i.lazySet(null);
+                if (th != null) {
+                    observer.onError(th);
+                } else {
+                    observer.onComplete();
+                }
+                return true;
+            }
+            Throwable th2 = this.f;
+            if (th2 != null) {
+                this.b.clear();
+                this.i.lazySet(null);
+                observer.onError(th2);
+                return true;
+            }
+            if (!z2) {
+                return false;
+            }
+            this.i.lazySet(null);
+            observer.onComplete();
+            return true;
+        }
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableGroupJoin.java

@@ -0,0 +1,351 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Observable;
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.CompositeDisposable;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.BiFunction;
+import io.reactivex.functions.Function;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.queue.SpscLinkedArrayQueue;
+import io.reactivex.internal.util.ExceptionHelper;
+import io.reactivex.plugins.RxJavaPlugins;
+import io.reactivex.subjects.UnicastSubject;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableGroupJoin<TLeft, TRight, TLeftEnd, TRightEnd, R> extends AbstractObservableWithUpstream<TLeft, R> {
+    final ObservableSource<? extends TRight> b;
+    final Function<? super TLeft, ? extends ObservableSource<TLeftEnd>> c;
+    final Function<? super TRight, ? extends ObservableSource<TRightEnd>> d;
+    final BiFunction<? super TLeft, ? super Observable<TRight>, ? extends R> e;
+
+    static final class GroupJoinDisposable<TLeft, TRight, TLeftEnd, TRightEnd, R> extends AtomicInteger implements Disposable, JoinSupport {
+        static final Integer n = 1;
+        static final Integer o = 2;
+        static final Integer p = 3;
+        static final Integer q = 4;
+        final Observer<? super R> a;
+        final Function<? super TLeft, ? extends ObservableSource<TLeftEnd>> g;
+        final Function<? super TRight, ? extends ObservableSource<TRightEnd>> h;
+        final BiFunction<? super TLeft, ? super Observable<TRight>, ? extends R> i;
+        int k;
+        int l;
+        volatile boolean m;
+        final CompositeDisposable c = new CompositeDisposable();
+        final SpscLinkedArrayQueue<Object> b = new SpscLinkedArrayQueue<>(Observable.bufferSize());
+        final Map<Integer, UnicastSubject<TRight>> d = new LinkedHashMap();
+        final Map<Integer, TRight> e = new LinkedHashMap();
+        final AtomicReference<Throwable> f = new AtomicReference<>();
+        final AtomicInteger j = new AtomicInteger(2);
+
+        GroupJoinDisposable(Observer<? super R> observer, Function<? super TLeft, ? extends ObservableSource<TLeftEnd>> function, Function<? super TRight, ? extends ObservableSource<TRightEnd>> function2, BiFunction<? super TLeft, ? super Observable<TRight>, ? extends R> biFunction) {
+            this.a = observer;
+            this.g = function;
+            this.h = function2;
+            this.i = biFunction;
+        }
+
+        void a() {
+            this.c.dispose();
+        }
+
+        void b() {
+            if (getAndIncrement() != 0) {
+                return;
+            }
+            SpscLinkedArrayQueue<?> spscLinkedArrayQueue = this.b;
+            Observer<? super R> observer = this.a;
+            int i = 1;
+            while (!this.m) {
+                if (this.f.get() != null) {
+                    spscLinkedArrayQueue.clear();
+                    a();
+                    a(observer);
+                    return;
+                }
+                boolean z = this.j.get() == 0;
+                Integer num = (Integer) spscLinkedArrayQueue.poll();
+                boolean z2 = num == null;
+                if (z && z2) {
+                    Iterator<UnicastSubject<TRight>> it = this.d.values().iterator();
+                    while (it.hasNext()) {
+                        it.next().onComplete();
+                    }
+                    this.d.clear();
+                    this.e.clear();
+                    this.c.dispose();
+                    observer.onComplete();
+                    return;
+                }
+                if (z2) {
+                    i = addAndGet(-i);
+                    if (i == 0) {
+                        return;
+                    }
+                } else {
+                    Object poll = spscLinkedArrayQueue.poll();
+                    if (num == n) {
+                        UnicastSubject d = UnicastSubject.d();
+                        int i2 = this.k;
+                        this.k = i2 + 1;
+                        this.d.put(Integer.valueOf(i2), d);
+                        try {
+                            ObservableSource apply = this.g.apply(poll);
+                            ObjectHelper.a(apply, "The leftEnd returned a null ObservableSource");
+                            ObservableSource observableSource = apply;
+                            LeftRightEndObserver leftRightEndObserver = new LeftRightEndObserver(this, true, i2);
+                            this.c.b(leftRightEndObserver);
+                            observableSource.subscribe(leftRightEndObserver);
+                            if (this.f.get() != null) {
+                                spscLinkedArrayQueue.clear();
+                                a();
+                                a(observer);
+                                return;
+                            }
+                            try {
+                                R apply2 = this.i.apply(poll, d);
+                                ObjectHelper.a(apply2, "The resultSelector returned a null value");
+                                observer.onNext(apply2);
+                                Iterator<TRight> it2 = this.e.values().iterator();
+                                while (it2.hasNext()) {
+                                    d.onNext(it2.next());
+                                }
+                            } catch (Throwable th) {
+                                a(th, observer, spscLinkedArrayQueue);
+                                return;
+                            }
+                        } catch (Throwable th2) {
+                            a(th2, observer, spscLinkedArrayQueue);
+                            return;
+                        }
+                    } else if (num == o) {
+                        int i3 = this.l;
+                        this.l = i3 + 1;
+                        this.e.put(Integer.valueOf(i3), poll);
+                        try {
+                            ObservableSource apply3 = this.h.apply(poll);
+                            ObjectHelper.a(apply3, "The rightEnd returned a null ObservableSource");
+                            ObservableSource observableSource2 = apply3;
+                            LeftRightEndObserver leftRightEndObserver2 = new LeftRightEndObserver(this, false, i3);
+                            this.c.b(leftRightEndObserver2);
+                            observableSource2.subscribe(leftRightEndObserver2);
+                            if (this.f.get() != null) {
+                                spscLinkedArrayQueue.clear();
+                                a();
+                                a(observer);
+                                return;
+                            } else {
+                                Iterator<UnicastSubject<TRight>> it3 = this.d.values().iterator();
+                                while (it3.hasNext()) {
+                                    it3.next().onNext(poll);
+                                }
+                            }
+                        } catch (Throwable th3) {
+                            a(th3, observer, spscLinkedArrayQueue);
+                            return;
+                        }
+                    } else if (num == p) {
+                        LeftRightEndObserver leftRightEndObserver3 = (LeftRightEndObserver) poll;
+                        UnicastSubject<TRight> remove = this.d.remove(Integer.valueOf(leftRightEndObserver3.c));
+                        this.c.a(leftRightEndObserver3);
+                        if (remove != null) {
+                            remove.onComplete();
+                        }
+                    } else if (num == q) {
+                        LeftRightEndObserver leftRightEndObserver4 = (LeftRightEndObserver) poll;
+                        this.e.remove(Integer.valueOf(leftRightEndObserver4.c));
+                        this.c.a(leftRightEndObserver4);
+                    }
+                }
+            }
+            spscLinkedArrayQueue.clear();
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            if (this.m) {
+                return;
+            }
+            this.m = true;
+            a();
+            if (getAndIncrement() == 0) {
+                this.b.clear();
+            }
+        }
+
+        void a(Observer<?> observer) {
+            Throwable a = ExceptionHelper.a(this.f);
+            Iterator<UnicastSubject<TRight>> it = this.d.values().iterator();
+            while (it.hasNext()) {
+                it.next().onError(a);
+            }
+            this.d.clear();
+            this.e.clear();
+            observer.onError(a);
+        }
+
+        void a(Throwable th, Observer<?> observer, SpscLinkedArrayQueue<?> spscLinkedArrayQueue) {
+            Exceptions.b(th);
+            ExceptionHelper.a(this.f, th);
+            spscLinkedArrayQueue.clear();
+            a();
+            a(observer);
+        }
+
+        @Override // io.reactivex.internal.operators.observable.ObservableGroupJoin.JoinSupport
+        public void a(LeftRightObserver leftRightObserver) {
+            this.c.c(leftRightObserver);
+            this.j.decrementAndGet();
+            b();
+        }
+
+        @Override // io.reactivex.internal.operators.observable.ObservableGroupJoin.JoinSupport
+        public void a(boolean z, Object obj) {
+            synchronized (this) {
+                this.b.a(z ? n : o, (Integer) obj);
+            }
+            b();
+        }
+
+        @Override // io.reactivex.internal.operators.observable.ObservableGroupJoin.JoinSupport
+        public void a(boolean z, LeftRightEndObserver leftRightEndObserver) {
+            synchronized (this) {
+                this.b.a(z ? p : q, (Integer) leftRightEndObserver);
+            }
+            b();
+        }
+
+        @Override // io.reactivex.internal.operators.observable.ObservableGroupJoin.JoinSupport
+        public void a(Throwable th) {
+            if (ExceptionHelper.a(this.f, th)) {
+                b();
+            } else {
+                RxJavaPlugins.b(th);
+            }
+        }
+
+        @Override // io.reactivex.internal.operators.observable.ObservableGroupJoin.JoinSupport
+        public void b(Throwable th) {
+            if (ExceptionHelper.a(this.f, th)) {
+                this.j.decrementAndGet();
+                b();
+            } else {
+                RxJavaPlugins.b(th);
+            }
+        }
+    }
+
+    interface JoinSupport {
+        void a(LeftRightObserver leftRightObserver);
+
+        void a(Throwable th);
+
+        void a(boolean z, LeftRightEndObserver leftRightEndObserver);
+
+        void a(boolean z, Object obj);
+
+        void b(Throwable th);
+    }
+
+    static final class LeftRightEndObserver extends AtomicReference<Disposable> implements Observer<Object>, Disposable {
+        final JoinSupport a;
+        final boolean b;
+        final int c;
+
+        LeftRightEndObserver(JoinSupport joinSupport, boolean z, int i) {
+            this.a = joinSupport;
+            this.b = z;
+            this.c = i;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            DisposableHelper.dispose(this);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.a.a(this.b, this);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            this.a.a(th);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(Object obj) {
+            if (DisposableHelper.dispose(this)) {
+                this.a.a(this.b, this);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            DisposableHelper.setOnce(this, disposable);
+        }
+    }
+
+    static final class LeftRightObserver extends AtomicReference<Disposable> implements Observer<Object>, Disposable {
+        final JoinSupport a;
+        final boolean b;
+
+        LeftRightObserver(JoinSupport joinSupport, boolean z) {
+            this.a = joinSupport;
+            this.b = z;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            DisposableHelper.dispose(this);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.a.a(this);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            this.a.b(th);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(Object obj) {
+            this.a.a(this.b, obj);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            DisposableHelper.setOnce(this, disposable);
+        }
+    }
+
+    public ObservableGroupJoin(ObservableSource<TLeft> observableSource, ObservableSource<? extends TRight> observableSource2, Function<? super TLeft, ? extends ObservableSource<TLeftEnd>> function, Function<? super TRight, ? extends ObservableSource<TRightEnd>> function2, BiFunction<? super TLeft, ? super Observable<TRight>, ? extends R> biFunction) {
+        super(observableSource);
+        this.b = observableSource2;
+        this.c = function;
+        this.d = function2;
+        this.e = biFunction;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super R> observer) {
+        GroupJoinDisposable groupJoinDisposable = new GroupJoinDisposable(observer, this.c, this.d, this.e);
+        observer.onSubscribe(groupJoinDisposable);
+        LeftRightObserver leftRightObserver = new LeftRightObserver(groupJoinDisposable, true);
+        groupJoinDisposable.c.b(leftRightObserver);
+        LeftRightObserver leftRightObserver2 = new LeftRightObserver(groupJoinDisposable, false);
+        groupJoinDisposable.c.b(leftRightObserver2);
+        this.a.subscribe(leftRightObserver);
+        this.b.subscribe(leftRightObserver2);
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableHide.java

@@ -0,0 +1,56 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+
+/* loaded from: classes2.dex */
+public final class ObservableHide<T> extends AbstractObservableWithUpstream<T, T> {
+
+    static final class HideDisposable<T> implements Observer<T>, Disposable {
+        final Observer<? super T> a;
+        Disposable b;
+
+        HideDisposable(Observer<? super T> observer) {
+            this.a = observer;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.b.dispose();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.a.onComplete();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            this.a.onError(th);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            this.a.onNext(t);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.b, disposable)) {
+                this.b = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+    }
+
+    public ObservableHide(ObservableSource<T> observableSource) {
+        super(observableSource);
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super T> observer) {
+        this.a.subscribe(new HideDisposable(observer));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableIgnoreElements.java

@@ -0,0 +1,52 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+
+/* loaded from: classes2.dex */
+public final class ObservableIgnoreElements<T> extends AbstractObservableWithUpstream<T, T> {
+
+    static final class IgnoreObservable<T> implements Observer<T>, Disposable {
+        final Observer<? super T> a;
+        Disposable b;
+
+        IgnoreObservable(Observer<? super T> observer) {
+            this.a = observer;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.b.dispose();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.a.onComplete();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            this.a.onError(th);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            this.b = disposable;
+            this.a.onSubscribe(this);
+        }
+    }
+
+    public ObservableIgnoreElements(ObservableSource<T> observableSource) {
+        super(observableSource);
+    }
+
+    @Override // io.reactivex.Observable
+    public void subscribeActual(Observer<? super T> observer) {
+        this.a.subscribe(new IgnoreObservable(observer));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableIgnoreElementsCompletable.java

@@ -0,0 +1,63 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Completable;
+import io.reactivex.CompletableObserver;
+import io.reactivex.Observable;
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.fuseable.FuseToObservable;
+import io.reactivex.plugins.RxJavaPlugins;
+
+/* loaded from: classes2.dex */
+public final class ObservableIgnoreElementsCompletable<T> extends Completable implements FuseToObservable<T> {
+    final ObservableSource<T> a;
+
+    static final class IgnoreObservable<T> implements Observer<T>, Disposable {
+        final CompletableObserver a;
+        Disposable b;
+
+        IgnoreObservable(CompletableObserver completableObserver) {
+            this.a = completableObserver;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.b.dispose();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.a.onComplete();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            this.a.onError(th);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            this.b = disposable;
+            this.a.onSubscribe(this);
+        }
+    }
+
+    public ObservableIgnoreElementsCompletable(ObservableSource<T> observableSource) {
+        this.a = observableSource;
+    }
+
+    @Override // io.reactivex.internal.fuseable.FuseToObservable
+    public Observable<T> a() {
+        return RxJavaPlugins.a(new ObservableIgnoreElements(this.a));
+    }
+
+    @Override // io.reactivex.Completable
+    public void b(CompletableObserver completableObserver) {
+        this.a.subscribe(new IgnoreObservable(completableObserver));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableInternalHelper.java

@@ -0,0 +1,338 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Emitter;
+import io.reactivex.Observable;
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.Scheduler;
+import io.reactivex.functions.Action;
+import io.reactivex.functions.BiConsumer;
+import io.reactivex.functions.BiFunction;
+import io.reactivex.functions.Consumer;
+import io.reactivex.functions.Function;
+import io.reactivex.internal.functions.Functions;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.observables.ConnectableObservable;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes2.dex */
+public final class ObservableInternalHelper {
+
+    static final class BufferedReplayCallable<T> implements Callable<ConnectableObservable<T>> {
+        private final Observable<T> a;
+        private final int b;
+
+        BufferedReplayCallable(Observable<T> observable, int i) {
+            this.a = observable;
+            this.b = i;
+        }
+
+        @Override // java.util.concurrent.Callable
+        public ConnectableObservable<T> call() {
+            return this.a.replay(this.b);
+        }
+    }
+
+    static final class BufferedTimedReplayCallable<T> implements Callable<ConnectableObservable<T>> {
+        private final Observable<T> a;
+        private final int b;
+        private final long c;
+        private final TimeUnit d;
+        private final Scheduler e;
+
+        BufferedTimedReplayCallable(Observable<T> observable, int i, long j, TimeUnit timeUnit, Scheduler scheduler) {
+            this.a = observable;
+            this.b = i;
+            this.c = j;
+            this.d = timeUnit;
+            this.e = scheduler;
+        }
+
+        @Override // java.util.concurrent.Callable
+        public ConnectableObservable<T> call() {
+            return this.a.replay(this.b, this.c, this.d, this.e);
+        }
+    }
+
+    static final class FlatMapIntoIterable<T, U> implements Function<T, ObservableSource<U>> {
+        private final Function<? super T, ? extends Iterable<? extends U>> a;
+
+        FlatMapIntoIterable(Function<? super T, ? extends Iterable<? extends U>> function) {
+            this.a = function;
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // io.reactivex.functions.Function
+        public /* bridge */ /* synthetic */ Object apply(Object obj) throws Exception {
+            return apply((FlatMapIntoIterable<T, U>) obj);
+        }
+
+        @Override // io.reactivex.functions.Function
+        public ObservableSource<U> apply(T t) throws Exception {
+            Iterable<? extends U> apply = this.a.apply(t);
+            ObjectHelper.a(apply, "The mapper returned a null Iterable");
+            return new ObservableFromIterable(apply);
+        }
+    }
+
+    static final class FlatMapWithCombinerInner<U, R, T> implements Function<U, R> {
+        private final BiFunction<? super T, ? super U, ? extends R> a;
+        private final T b;
+
+        FlatMapWithCombinerInner(BiFunction<? super T, ? super U, ? extends R> biFunction, T t) {
+            this.a = biFunction;
+            this.b = t;
+        }
+
+        @Override // io.reactivex.functions.Function
+        public R apply(U u) throws Exception {
+            return this.a.apply(this.b, u);
+        }
+    }
+
+    static final class FlatMapWithCombinerOuter<T, R, U> implements Function<T, ObservableSource<R>> {
+        private final BiFunction<? super T, ? super U, ? extends R> a;
+        private final Function<? super T, ? extends ObservableSource<? extends U>> b;
+
+        FlatMapWithCombinerOuter(BiFunction<? super T, ? super U, ? extends R> biFunction, Function<? super T, ? extends ObservableSource<? extends U>> function) {
+            this.a = biFunction;
+            this.b = function;
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // io.reactivex.functions.Function
+        public /* bridge */ /* synthetic */ Object apply(Object obj) throws Exception {
+            return apply((FlatMapWithCombinerOuter<T, R, U>) obj);
+        }
+
+        @Override // io.reactivex.functions.Function
+        public ObservableSource<R> apply(T t) throws Exception {
+            ObservableSource<? extends U> apply = this.b.apply(t);
+            ObjectHelper.a(apply, "The mapper returned a null ObservableSource");
+            return new ObservableMap(apply, new FlatMapWithCombinerInner(this.a, t));
+        }
+    }
+
+    static final class ItemDelayFunction<T, U> implements Function<T, ObservableSource<T>> {
+        final Function<? super T, ? extends ObservableSource<U>> a;
+
+        ItemDelayFunction(Function<? super T, ? extends ObservableSource<U>> function) {
+            this.a = function;
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // io.reactivex.functions.Function
+        public /* bridge */ /* synthetic */ Object apply(Object obj) throws Exception {
+            return apply((ItemDelayFunction<T, U>) obj);
+        }
+
+        @Override // io.reactivex.functions.Function
+        public ObservableSource<T> apply(T t) throws Exception {
+            ObservableSource<U> apply = this.a.apply(t);
+            ObjectHelper.a(apply, "The itemDelay returned a null ObservableSource");
+            return new ObservableTake(apply, 1L).map(Functions.c(t)).defaultIfEmpty(t);
+        }
+    }
+
+    static final class ObserverOnComplete<T> implements Action {
+        final Observer<T> a;
+
+        ObserverOnComplete(Observer<T> observer) {
+            this.a = observer;
+        }
+
+        @Override // io.reactivex.functions.Action
+        public void run() throws Exception {
+            this.a.onComplete();
+        }
+    }
+
+    static final class ObserverOnError<T> implements Consumer<Throwable> {
+        final Observer<T> a;
+
+        ObserverOnError(Observer<T> observer) {
+            this.a = observer;
+        }
+
+        @Override // io.reactivex.functions.Consumer
+        /* renamed from: a, reason: merged with bridge method [inline-methods] */
+        public void accept(Throwable th) throws Exception {
+            this.a.onError(th);
+        }
+    }
+
+    static final class ObserverOnNext<T> implements Consumer<T> {
+        final Observer<T> a;
+
+        ObserverOnNext(Observer<T> observer) {
+            this.a = observer;
+        }
+
+        @Override // io.reactivex.functions.Consumer
+        public void accept(T t) throws Exception {
+            this.a.onNext(t);
+        }
+    }
+
+    static final class ReplayCallable<T> implements Callable<ConnectableObservable<T>> {
+        private final Observable<T> a;
+
+        ReplayCallable(Observable<T> observable) {
+            this.a = observable;
+        }
+
+        @Override // java.util.concurrent.Callable
+        public ConnectableObservable<T> call() {
+            return this.a.replay();
+        }
+    }
+
+    static final class ReplayFunction<T, R> implements Function<Observable<T>, ObservableSource<R>> {
+        private final Function<? super Observable<T>, ? extends ObservableSource<R>> a;
+        private final Scheduler b;
+
+        ReplayFunction(Function<? super Observable<T>, ? extends ObservableSource<R>> function, Scheduler scheduler) {
+            this.a = function;
+            this.b = scheduler;
+        }
+
+        @Override // io.reactivex.functions.Function
+        /* renamed from: a, reason: merged with bridge method [inline-methods] */
+        public ObservableSource<R> apply(Observable<T> observable) throws Exception {
+            ObservableSource<R> apply = this.a.apply(observable);
+            ObjectHelper.a(apply, "The selector returned a null ObservableSource");
+            return Observable.wrap(apply).observeOn(this.b);
+        }
+    }
+
+    static final class SimpleBiGenerator<T, S> implements BiFunction<S, Emitter<T>, S> {
+        final BiConsumer<S, Emitter<T>> a;
+
+        SimpleBiGenerator(BiConsumer<S, Emitter<T>> biConsumer) {
+            this.a = biConsumer;
+        }
+
+        public S a(S s, Emitter<T> emitter) throws Exception {
+            this.a.a(s, emitter);
+            return s;
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // io.reactivex.functions.BiFunction
+        public /* bridge */ /* synthetic */ Object apply(Object obj, Object obj2) throws Exception {
+            a(obj, (Emitter) obj2);
+            return obj;
+        }
+    }
+
+    static final class SimpleGenerator<T, S> implements BiFunction<S, Emitter<T>, S> {
+        final Consumer<Emitter<T>> a;
+
+        SimpleGenerator(Consumer<Emitter<T>> consumer) {
+            this.a = consumer;
+        }
+
+        public S a(S s, Emitter<T> emitter) throws Exception {
+            this.a.accept(emitter);
+            return s;
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // io.reactivex.functions.BiFunction
+        public /* bridge */ /* synthetic */ Object apply(Object obj, Object obj2) throws Exception {
+            a(obj, (Emitter) obj2);
+            return obj;
+        }
+    }
+
+    static final class TimedReplayCallable<T> implements Callable<ConnectableObservable<T>> {
+        private final Observable<T> a;
+        private final long b;
+        private final TimeUnit c;
+        private final Scheduler d;
+
+        TimedReplayCallable(Observable<T> observable, long j, TimeUnit timeUnit, Scheduler scheduler) {
+            this.a = observable;
+            this.b = j;
+            this.c = timeUnit;
+            this.d = scheduler;
+        }
+
+        @Override // java.util.concurrent.Callable
+        public ConnectableObservable<T> call() {
+            return this.a.replay(this.b, this.c, this.d);
+        }
+    }
+
+    static final class ZipIterableFunction<T, R> implements Function<List<ObservableSource<? extends T>>, ObservableSource<? extends R>> {
+        private final Function<? super Object[], ? extends R> a;
+
+        ZipIterableFunction(Function<? super Object[], ? extends R> function) {
+            this.a = function;
+        }
+
+        @Override // io.reactivex.functions.Function
+        /* renamed from: a, reason: merged with bridge method [inline-methods] */
+        public ObservableSource<? extends R> apply(List<ObservableSource<? extends T>> list) {
+            return Observable.zipIterable(list, this.a, false, Observable.bufferSize());
+        }
+    }
+
+    public static <T, S> BiFunction<S, Emitter<T>, S> a(Consumer<Emitter<T>> consumer) {
+        return new SimpleGenerator(consumer);
+    }
+
+    public static <T, U> Function<T, ObservableSource<T>> b(Function<? super T, ? extends ObservableSource<U>> function) {
+        return new ItemDelayFunction(function);
+    }
+
+    public static <T> Consumer<T> c(Observer<T> observer) {
+        return new ObserverOnNext(observer);
+    }
+
+    public static <T, S> BiFunction<S, Emitter<T>, S> a(BiConsumer<S, Emitter<T>> biConsumer) {
+        return new SimpleBiGenerator(biConsumer);
+    }
+
+    public static <T> Consumer<Throwable> b(Observer<T> observer) {
+        return new ObserverOnError(observer);
+    }
+
+    public static <T, R> Function<List<ObservableSource<? extends T>>, ObservableSource<? extends R>> c(Function<? super Object[], ? extends R> function) {
+        return new ZipIterableFunction(function);
+    }
+
+    public static <T> Action a(Observer<T> observer) {
+        return new ObserverOnComplete(observer);
+    }
+
+    public static <T, U, R> Function<T, ObservableSource<R>> a(Function<? super T, ? extends ObservableSource<? extends U>> function, BiFunction<? super T, ? super U, ? extends R> biFunction) {
+        return new FlatMapWithCombinerOuter(biFunction, function);
+    }
+
+    public static <T, U> Function<T, ObservableSource<U>> a(Function<? super T, ? extends Iterable<? extends U>> function) {
+        return new FlatMapIntoIterable(function);
+    }
+
+    public static <T> Callable<ConnectableObservable<T>> a(Observable<T> observable) {
+        return new ReplayCallable(observable);
+    }
+
+    public static <T> Callable<ConnectableObservable<T>> a(Observable<T> observable, int i) {
+        return new BufferedReplayCallable(observable, i);
+    }
+
+    public static <T> Callable<ConnectableObservable<T>> a(Observable<T> observable, int i, long j, TimeUnit timeUnit, Scheduler scheduler) {
+        return new BufferedTimedReplayCallable(observable, i, j, timeUnit, scheduler);
+    }
+
+    public static <T> Callable<ConnectableObservable<T>> a(Observable<T> observable, long j, TimeUnit timeUnit, Scheduler scheduler) {
+        return new TimedReplayCallable(observable, j, timeUnit, scheduler);
+    }
+
+    public static <T, R> Function<Observable<T>, ObservableSource<R>> a(Function<? super Observable<T>, ? extends ObservableSource<R>> function, Scheduler scheduler) {
+        return new ReplayFunction(function, scheduler);
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableInterval.java

@@ -0,0 +1,67 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.Scheduler;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.schedulers.TrampolineScheduler;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableInterval extends Observable<Long> {
+    final Scheduler a;
+    final long b;
+    final long c;
+    final TimeUnit d;
+
+    static final class IntervalObserver extends AtomicReference<Disposable> implements Disposable, Runnable {
+        final Observer<? super Long> a;
+        long b;
+
+        IntervalObserver(Observer<? super Long> observer) {
+            this.a = observer;
+        }
+
+        public void a(Disposable disposable) {
+            DisposableHelper.setOnce(this, disposable);
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            DisposableHelper.dispose(this);
+        }
+
+        @Override // java.lang.Runnable
+        public void run() {
+            if (get() != DisposableHelper.DISPOSED) {
+                Observer<? super Long> observer = this.a;
+                long j = this.b;
+                this.b = 1 + j;
+                observer.onNext(Long.valueOf(j));
+            }
+        }
+    }
+
+    public ObservableInterval(long j, long j2, TimeUnit timeUnit, Scheduler scheduler) {
+        this.b = j;
+        this.c = j2;
+        this.d = timeUnit;
+        this.a = scheduler;
+    }
+
+    @Override // io.reactivex.Observable
+    public void subscribeActual(Observer<? super Long> observer) {
+        IntervalObserver intervalObserver = new IntervalObserver(observer);
+        observer.onSubscribe(intervalObserver);
+        Scheduler scheduler = this.a;
+        if (!(scheduler instanceof TrampolineScheduler)) {
+            intervalObserver.a(scheduler.a(intervalObserver, this.b, this.c, this.d));
+            return;
+        }
+        Scheduler.Worker a = scheduler.a();
+        intervalObserver.a(a);
+        a.a(intervalObserver, this.b, this.c, this.d);
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableIntervalRange.java

@@ -0,0 +1,83 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.Scheduler;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.schedulers.TrampolineScheduler;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableIntervalRange extends Observable<Long> {
+    final Scheduler a;
+    final long b;
+    final long c;
+    final long d;
+    final long e;
+    final TimeUnit f;
+
+    static final class IntervalRangeObserver extends AtomicReference<Disposable> implements Disposable, Runnable {
+        final Observer<? super Long> a;
+        final long b;
+        long c;
+
+        IntervalRangeObserver(Observer<? super Long> observer, long j, long j2) {
+            this.a = observer;
+            this.c = j;
+            this.b = j2;
+        }
+
+        public boolean a() {
+            return get() == DisposableHelper.DISPOSED;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            DisposableHelper.dispose(this);
+        }
+
+        @Override // java.lang.Runnable
+        public void run() {
+            if (a()) {
+                return;
+            }
+            long j = this.c;
+            this.a.onNext(Long.valueOf(j));
+            if (j != this.b) {
+                this.c = j + 1;
+            } else {
+                DisposableHelper.dispose(this);
+                this.a.onComplete();
+            }
+        }
+
+        public void a(Disposable disposable) {
+            DisposableHelper.setOnce(this, disposable);
+        }
+    }
+
+    public ObservableIntervalRange(long j, long j2, long j3, long j4, TimeUnit timeUnit, Scheduler scheduler) {
+        this.d = j3;
+        this.e = j4;
+        this.f = timeUnit;
+        this.a = scheduler;
+        this.b = j;
+        this.c = j2;
+    }
+
+    @Override // io.reactivex.Observable
+    public void subscribeActual(Observer<? super Long> observer) {
+        IntervalRangeObserver intervalRangeObserver = new IntervalRangeObserver(observer, this.b, this.c);
+        observer.onSubscribe(intervalRangeObserver);
+        Scheduler scheduler = this.a;
+        if (!(scheduler instanceof TrampolineScheduler)) {
+            intervalRangeObserver.a(scheduler.a(intervalRangeObserver, this.d, this.e, this.f));
+            return;
+        }
+        Scheduler.Worker a = scheduler.a();
+        intervalRangeObserver.a(a);
+        a.a(intervalRangeObserver, this.d, this.e, this.f);
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableJoin.java

@@ -0,0 +1,257 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Observable;
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.CompositeDisposable;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.BiFunction;
+import io.reactivex.functions.Function;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.operators.observable.ObservableGroupJoin;
+import io.reactivex.internal.queue.SpscLinkedArrayQueue;
+import io.reactivex.internal.util.ExceptionHelper;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableJoin<TLeft, TRight, TLeftEnd, TRightEnd, R> extends AbstractObservableWithUpstream<TLeft, R> {
+    final ObservableSource<? extends TRight> b;
+    final Function<? super TLeft, ? extends ObservableSource<TLeftEnd>> c;
+    final Function<? super TRight, ? extends ObservableSource<TRightEnd>> d;
+    final BiFunction<? super TLeft, ? super TRight, ? extends R> e;
+
+    static final class JoinDisposable<TLeft, TRight, TLeftEnd, TRightEnd, R> extends AtomicInteger implements Disposable, ObservableGroupJoin.JoinSupport {
+        static final Integer n = 1;
+        static final Integer o = 2;
+        static final Integer p = 3;
+        static final Integer q = 4;
+        final Observer<? super R> a;
+        final Function<? super TLeft, ? extends ObservableSource<TLeftEnd>> g;
+        final Function<? super TRight, ? extends ObservableSource<TRightEnd>> h;
+        final BiFunction<? super TLeft, ? super TRight, ? extends R> i;
+        int k;
+        int l;
+        volatile boolean m;
+        final CompositeDisposable c = new CompositeDisposable();
+        final SpscLinkedArrayQueue<Object> b = new SpscLinkedArrayQueue<>(Observable.bufferSize());
+        final Map<Integer, TLeft> d = new LinkedHashMap();
+        final Map<Integer, TRight> e = new LinkedHashMap();
+        final AtomicReference<Throwable> f = new AtomicReference<>();
+        final AtomicInteger j = new AtomicInteger(2);
+
+        JoinDisposable(Observer<? super R> observer, Function<? super TLeft, ? extends ObservableSource<TLeftEnd>> function, Function<? super TRight, ? extends ObservableSource<TRightEnd>> function2, BiFunction<? super TLeft, ? super TRight, ? extends R> biFunction) {
+            this.a = observer;
+            this.g = function;
+            this.h = function2;
+            this.i = biFunction;
+        }
+
+        void a() {
+            this.c.dispose();
+        }
+
+        void b() {
+            if (getAndIncrement() != 0) {
+                return;
+            }
+            SpscLinkedArrayQueue<?> spscLinkedArrayQueue = this.b;
+            Observer<? super R> observer = this.a;
+            int i = 1;
+            while (!this.m) {
+                if (this.f.get() != null) {
+                    spscLinkedArrayQueue.clear();
+                    a();
+                    a(observer);
+                    return;
+                }
+                boolean z = this.j.get() == 0;
+                Integer num = (Integer) spscLinkedArrayQueue.poll();
+                boolean z2 = num == null;
+                if (z && z2) {
+                    this.d.clear();
+                    this.e.clear();
+                    this.c.dispose();
+                    observer.onComplete();
+                    return;
+                }
+                if (z2) {
+                    i = addAndGet(-i);
+                    if (i == 0) {
+                        return;
+                    }
+                } else {
+                    Object poll = spscLinkedArrayQueue.poll();
+                    if (num == n) {
+                        int i2 = this.k;
+                        this.k = i2 + 1;
+                        this.d.put(Integer.valueOf(i2), poll);
+                        try {
+                            ObservableSource apply = this.g.apply(poll);
+                            ObjectHelper.a(apply, "The leftEnd returned a null ObservableSource");
+                            ObservableSource observableSource = apply;
+                            ObservableGroupJoin.LeftRightEndObserver leftRightEndObserver = new ObservableGroupJoin.LeftRightEndObserver(this, true, i2);
+                            this.c.b(leftRightEndObserver);
+                            observableSource.subscribe(leftRightEndObserver);
+                            if (this.f.get() != null) {
+                                spscLinkedArrayQueue.clear();
+                                a();
+                                a(observer);
+                                return;
+                            }
+                            Iterator<TRight> it = this.e.values().iterator();
+                            while (it.hasNext()) {
+                                try {
+                                    R apply2 = this.i.apply(poll, it.next());
+                                    ObjectHelper.a(apply2, "The resultSelector returned a null value");
+                                    observer.onNext(apply2);
+                                } catch (Throwable th) {
+                                    a(th, observer, spscLinkedArrayQueue);
+                                    return;
+                                }
+                            }
+                        } catch (Throwable th2) {
+                            a(th2, observer, spscLinkedArrayQueue);
+                            return;
+                        }
+                    } else if (num == o) {
+                        int i3 = this.l;
+                        this.l = i3 + 1;
+                        this.e.put(Integer.valueOf(i3), poll);
+                        try {
+                            ObservableSource apply3 = this.h.apply(poll);
+                            ObjectHelper.a(apply3, "The rightEnd returned a null ObservableSource");
+                            ObservableSource observableSource2 = apply3;
+                            ObservableGroupJoin.LeftRightEndObserver leftRightEndObserver2 = new ObservableGroupJoin.LeftRightEndObserver(this, false, i3);
+                            this.c.b(leftRightEndObserver2);
+                            observableSource2.subscribe(leftRightEndObserver2);
+                            if (this.f.get() != null) {
+                                spscLinkedArrayQueue.clear();
+                                a();
+                                a(observer);
+                                return;
+                            }
+                            Iterator<TLeft> it2 = this.d.values().iterator();
+                            while (it2.hasNext()) {
+                                try {
+                                    R apply4 = this.i.apply(it2.next(), poll);
+                                    ObjectHelper.a(apply4, "The resultSelector returned a null value");
+                                    observer.onNext(apply4);
+                                } catch (Throwable th3) {
+                                    a(th3, observer, spscLinkedArrayQueue);
+                                    return;
+                                }
+                            }
+                        } catch (Throwable th4) {
+                            a(th4, observer, spscLinkedArrayQueue);
+                            return;
+                        }
+                    } else if (num == p) {
+                        ObservableGroupJoin.LeftRightEndObserver leftRightEndObserver3 = (ObservableGroupJoin.LeftRightEndObserver) poll;
+                        this.d.remove(Integer.valueOf(leftRightEndObserver3.c));
+                        this.c.a(leftRightEndObserver3);
+                    } else {
+                        ObservableGroupJoin.LeftRightEndObserver leftRightEndObserver4 = (ObservableGroupJoin.LeftRightEndObserver) poll;
+                        this.e.remove(Integer.valueOf(leftRightEndObserver4.c));
+                        this.c.a(leftRightEndObserver4);
+                    }
+                }
+            }
+            spscLinkedArrayQueue.clear();
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            if (this.m) {
+                return;
+            }
+            this.m = true;
+            a();
+            if (getAndIncrement() == 0) {
+                this.b.clear();
+            }
+        }
+
+        void a(Observer<?> observer) {
+            Throwable a = ExceptionHelper.a(this.f);
+            this.d.clear();
+            this.e.clear();
+            observer.onError(a);
+        }
+
+        void a(Throwable th, Observer<?> observer, SpscLinkedArrayQueue<?> spscLinkedArrayQueue) {
+            Exceptions.b(th);
+            ExceptionHelper.a(this.f, th);
+            spscLinkedArrayQueue.clear();
+            a();
+            a(observer);
+        }
+
+        @Override // io.reactivex.internal.operators.observable.ObservableGroupJoin.JoinSupport
+        public void a(ObservableGroupJoin.LeftRightObserver leftRightObserver) {
+            this.c.c(leftRightObserver);
+            this.j.decrementAndGet();
+            b();
+        }
+
+        @Override // io.reactivex.internal.operators.observable.ObservableGroupJoin.JoinSupport
+        public void a(boolean z, Object obj) {
+            synchronized (this) {
+                this.b.a(z ? n : o, (Integer) obj);
+            }
+            b();
+        }
+
+        @Override // io.reactivex.internal.operators.observable.ObservableGroupJoin.JoinSupport
+        public void a(boolean z, ObservableGroupJoin.LeftRightEndObserver leftRightEndObserver) {
+            synchronized (this) {
+                this.b.a(z ? p : q, (Integer) leftRightEndObserver);
+            }
+            b();
+        }
+
+        @Override // io.reactivex.internal.operators.observable.ObservableGroupJoin.JoinSupport
+        public void a(Throwable th) {
+            if (ExceptionHelper.a(this.f, th)) {
+                b();
+            } else {
+                RxJavaPlugins.b(th);
+            }
+        }
+
+        @Override // io.reactivex.internal.operators.observable.ObservableGroupJoin.JoinSupport
+        public void b(Throwable th) {
+            if (ExceptionHelper.a(this.f, th)) {
+                this.j.decrementAndGet();
+                b();
+            } else {
+                RxJavaPlugins.b(th);
+            }
+        }
+    }
+
+    public ObservableJoin(ObservableSource<TLeft> observableSource, ObservableSource<? extends TRight> observableSource2, Function<? super TLeft, ? extends ObservableSource<TLeftEnd>> function, Function<? super TRight, ? extends ObservableSource<TRightEnd>> function2, BiFunction<? super TLeft, ? super TRight, ? extends R> biFunction) {
+        super(observableSource);
+        this.b = observableSource2;
+        this.c = function;
+        this.d = function2;
+        this.e = biFunction;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super R> observer) {
+        JoinDisposable joinDisposable = new JoinDisposable(observer, this.c, this.d, this.e);
+        observer.onSubscribe(joinDisposable);
+        ObservableGroupJoin.LeftRightObserver leftRightObserver = new ObservableGroupJoin.LeftRightObserver(joinDisposable, true);
+        joinDisposable.c.b(leftRightObserver);
+        ObservableGroupJoin.LeftRightObserver leftRightObserver2 = new ObservableGroupJoin.LeftRightObserver(joinDisposable, false);
+        joinDisposable.c.b(leftRightObserver2);
+        this.a.subscribe(leftRightObserver);
+        this.b.subscribe(leftRightObserver2);
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableJust.java

@@ -0,0 +1,27 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.internal.fuseable.ScalarCallable;
+import io.reactivex.internal.operators.observable.ObservableScalarXMap;
+
+/* loaded from: classes2.dex */
+public final class ObservableJust<T> extends Observable<T> implements ScalarCallable<T> {
+    private final T a;
+
+    public ObservableJust(T t) {
+        this.a = t;
+    }
+
+    @Override // io.reactivex.internal.fuseable.ScalarCallable, java.util.concurrent.Callable
+    public T call() {
+        return this.a;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super T> observer) {
+        ObservableScalarXMap.ScalarDisposable scalarDisposable = new ObservableScalarXMap.ScalarDisposable(observer, this.a);
+        observer.onSubscribe(scalarDisposable);
+        scalarDisposable.run();
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableLastMaybe.java

@@ -0,0 +1,70 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Maybe;
+import io.reactivex.MaybeObserver;
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+
+/* loaded from: classes2.dex */
+public final class ObservableLastMaybe<T> extends Maybe<T> {
+    final ObservableSource<T> a;
+
+    static final class LastObserver<T> implements Observer<T>, Disposable {
+        final MaybeObserver<? super T> a;
+        Disposable b;
+        T c;
+
+        LastObserver(MaybeObserver<? super T> maybeObserver) {
+            this.a = maybeObserver;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.b.dispose();
+            this.b = DisposableHelper.DISPOSED;
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.b = DisposableHelper.DISPOSED;
+            T t = this.c;
+            if (t == null) {
+                this.a.onComplete();
+            } else {
+                this.c = null;
+                this.a.onSuccess(t);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            this.b = DisposableHelper.DISPOSED;
+            this.c = null;
+            this.a.onError(th);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            this.c = t;
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.b, disposable)) {
+                this.b = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+    }
+
+    public ObservableLastMaybe(ObservableSource<T> observableSource) {
+        this.a = observableSource;
+    }
+
+    @Override // io.reactivex.Maybe
+    protected void b(MaybeObserver<? super T> maybeObserver) {
+        this.a.subscribe(new LastObserver(maybeObserver));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableLastSingle.java

@@ -0,0 +1,80 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.Single;
+import io.reactivex.SingleObserver;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+import java.util.NoSuchElementException;
+
+/* loaded from: classes2.dex */
+public final class ObservableLastSingle<T> extends Single<T> {
+    final ObservableSource<T> a;
+    final T b;
+
+    static final class LastObserver<T> implements Observer<T>, Disposable {
+        final SingleObserver<? super T> a;
+        final T b;
+        Disposable c;
+        T d;
+
+        LastObserver(SingleObserver<? super T> singleObserver, T t) {
+            this.a = singleObserver;
+            this.b = t;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.c.dispose();
+            this.c = DisposableHelper.DISPOSED;
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.c = DisposableHelper.DISPOSED;
+            T t = this.d;
+            if (t != null) {
+                this.d = null;
+                this.a.onSuccess(t);
+                return;
+            }
+            T t2 = this.b;
+            if (t2 != null) {
+                this.a.onSuccess(t2);
+            } else {
+                this.a.onError(new NoSuchElementException());
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            this.c = DisposableHelper.DISPOSED;
+            this.d = null;
+            this.a.onError(th);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            this.d = t;
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.c, disposable)) {
+                this.c = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+    }
+
+    public ObservableLastSingle(ObservableSource<T> observableSource, T t) {
+        this.a = observableSource;
+        this.b = t;
+    }
+
+    @Override // io.reactivex.Single
+    protected void b(SingleObserver<? super T> singleObserver) {
+        this.a.subscribe(new LastObserver(singleObserver, this.b));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableLift.java

@@ -0,0 +1,35 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableOperator;
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.plugins.RxJavaPlugins;
+
+/* loaded from: classes2.dex */
+public final class ObservableLift<R, T> extends AbstractObservableWithUpstream<T, R> {
+    final ObservableOperator<? extends R, ? super T> b;
+
+    public ObservableLift(ObservableSource<T> observableSource, ObservableOperator<? extends R, ? super T> observableOperator) {
+        super(observableSource);
+        this.b = observableOperator;
+    }
+
+    @Override // io.reactivex.Observable
+    public void subscribeActual(Observer<? super R> observer) {
+        try {
+            Observer<? super Object> a = this.b.a(observer);
+            ObjectHelper.a(a, "Operator " + this.b + " returned a null Observer");
+            this.a.subscribe(a);
+        } catch (NullPointerException e) {
+            throw e;
+        } catch (Throwable th) {
+            Exceptions.b(th);
+            RxJavaPlugins.b(th);
+            NullPointerException nullPointerException = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
+            nullPointerException.initCause(th);
+            throw nullPointerException;
+        }
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableMap.java

@@ -0,0 +1,65 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.functions.Function;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.observers.BasicFuseableObserver;
+
+/* loaded from: classes2.dex */
+public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
+    final Function<? super T, ? extends U> b;
+
+    static final class MapObserver<T, U> extends BasicFuseableObserver<T, U> {
+        final Function<? super T, ? extends U> f;
+
+        MapObserver(Observer<? super U> observer, Function<? super T, ? extends U> function) {
+            super(observer);
+            this.f = function;
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            if (this.d) {
+                return;
+            }
+            if (this.e != 0) {
+                this.a.onNext(null);
+                return;
+            }
+            try {
+                U apply = this.f.apply(t);
+                ObjectHelper.a(apply, "The mapper function returned a null value.");
+                this.a.onNext(apply);
+            } catch (Throwable th) {
+                a(th);
+            }
+        }
+
+        @Override // io.reactivex.internal.fuseable.SimpleQueue
+        public U poll() throws Exception {
+            T poll = this.c.poll();
+            if (poll == null) {
+                return null;
+            }
+            U apply = this.f.apply(poll);
+            ObjectHelper.a(apply, "The mapper function returned a null value.");
+            return apply;
+        }
+
+        @Override // io.reactivex.internal.fuseable.QueueFuseable
+        public int requestFusion(int i) {
+            return a(i);
+        }
+    }
+
+    public ObservableMap(ObservableSource<T> observableSource, Function<? super T, ? extends U> function) {
+        super(observableSource);
+        this.b = function;
+    }
+
+    @Override // io.reactivex.Observable
+    public void subscribeActual(Observer<? super U> observer) {
+        this.a.subscribe(new MapObserver(observer, this.b));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableMapNotification.java

@@ -0,0 +1,96 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.CompositeException;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Function;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.functions.ObjectHelper;
+import java.util.concurrent.Callable;
+
+/* loaded from: classes2.dex */
+public final class ObservableMapNotification<T, R> extends AbstractObservableWithUpstream<T, ObservableSource<? extends R>> {
+    final Function<? super T, ? extends ObservableSource<? extends R>> b;
+    final Function<? super Throwable, ? extends ObservableSource<? extends R>> c;
+    final Callable<? extends ObservableSource<? extends R>> d;
+
+    static final class MapNotificationObserver<T, R> implements Observer<T>, Disposable {
+        final Observer<? super ObservableSource<? extends R>> a;
+        final Function<? super T, ? extends ObservableSource<? extends R>> b;
+        final Function<? super Throwable, ? extends ObservableSource<? extends R>> c;
+        final Callable<? extends ObservableSource<? extends R>> d;
+        Disposable e;
+
+        MapNotificationObserver(Observer<? super ObservableSource<? extends R>> observer, Function<? super T, ? extends ObservableSource<? extends R>> function, Function<? super Throwable, ? extends ObservableSource<? extends R>> function2, Callable<? extends ObservableSource<? extends R>> callable) {
+            this.a = observer;
+            this.b = function;
+            this.c = function2;
+            this.d = callable;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.e.dispose();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            try {
+                ObservableSource<? extends R> call = this.d.call();
+                ObjectHelper.a(call, "The onComplete ObservableSource returned is null");
+                this.a.onNext(call);
+                this.a.onComplete();
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                this.a.onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            try {
+                ObservableSource<? extends R> apply = this.c.apply(th);
+                ObjectHelper.a(apply, "The onError ObservableSource returned is null");
+                this.a.onNext(apply);
+                this.a.onComplete();
+            } catch (Throwable th2) {
+                Exceptions.b(th2);
+                this.a.onError(new CompositeException(th, th2));
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            try {
+                ObservableSource<? extends R> apply = this.b.apply(t);
+                ObjectHelper.a(apply, "The onNext ObservableSource returned is null");
+                this.a.onNext(apply);
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                this.a.onError(th);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.e, disposable)) {
+                this.e = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+    }
+
+    public ObservableMapNotification(ObservableSource<T> observableSource, Function<? super T, ? extends ObservableSource<? extends R>> function, Function<? super Throwable, ? extends ObservableSource<? extends R>> function2, Callable<? extends ObservableSource<? extends R>> callable) {
+        super(observableSource);
+        this.b = function;
+        this.c = function2;
+        this.d = callable;
+    }
+
+    @Override // io.reactivex.Observable
+    public void subscribeActual(Observer<? super ObservableSource<? extends R>> observer) {
+        this.a.subscribe(new MapNotificationObserver(observer, this.b, this.c, this.d));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableMaterialize.java

@@ -0,0 +1,59 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.Notification;
+import io.reactivex.ObservableSource;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+
+/* loaded from: classes2.dex */
+public final class ObservableMaterialize<T> extends AbstractObservableWithUpstream<T, Notification<T>> {
+
+    static final class MaterializeObserver<T> implements Observer<T>, Disposable {
+        final Observer<? super Notification<T>> a;
+        Disposable b;
+
+        MaterializeObserver(Observer<? super Notification<T>> observer) {
+            this.a = observer;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.b.dispose();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.a.onNext(Notification.f());
+            this.a.onComplete();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            this.a.onNext(Notification.a(th));
+            this.a.onComplete();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            this.a.onNext(Notification.a(t));
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.b, disposable)) {
+                this.b = disposable;
+                this.a.onSubscribe(this);
+            }
+        }
+    }
+
+    public ObservableMaterialize(ObservableSource<T> observableSource) {
+        super(observableSource);
+    }
+
+    @Override // io.reactivex.Observable
+    public void subscribeActual(Observer<? super Notification<T>> observer) {
+        this.a.subscribe(new MaterializeObserver(observer));
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableMergeWithCompletable.java

@@ -0,0 +1,108 @@
+package io.reactivex.internal.operators.observable;
+
+import io.reactivex.CompletableObserver;
+import io.reactivex.CompletableSource;
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.util.AtomicThrowable;
+import io.reactivex.internal.util.HalfSerializer;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableMergeWithCompletable<T> extends AbstractObservableWithUpstream<T, T> {
+    final CompletableSource b;
+
+    public ObservableMergeWithCompletable(Observable<T> observable, CompletableSource completableSource) {
+        super(observable);
+        this.b = completableSource;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super T> observer) {
+        MergeWithObserver mergeWithObserver = new MergeWithObserver(observer);
+        observer.onSubscribe(mergeWithObserver);
+        this.a.subscribe(mergeWithObserver);
+        this.b.a(mergeWithObserver.c);
+    }
+
+    static final class MergeWithObserver<T> extends AtomicInteger implements Observer<T>, Disposable {
+        final Observer<? super T> a;
+        final AtomicReference<Disposable> b = new AtomicReference<>();
+        final OtherObserver c = new OtherObserver(this);
+        final AtomicThrowable d = new AtomicThrowable();
+        volatile boolean e;
+        volatile boolean f;
+
+        static final class OtherObserver extends AtomicReference<Disposable> implements CompletableObserver {
+            final MergeWithObserver<?> a;
+
+            OtherObserver(MergeWithObserver<?> mergeWithObserver) {
+                this.a = mergeWithObserver;
+            }
+
+            @Override // io.reactivex.CompletableObserver, io.reactivex.MaybeObserver
+            public void onComplete() {
+                this.a.a();
+            }
+
+            @Override // io.reactivex.CompletableObserver
+            public void onError(Throwable th) {
+                this.a.a(th);
+            }
+
+            @Override // io.reactivex.CompletableObserver
+            public void onSubscribe(Disposable disposable) {
+                DisposableHelper.setOnce(this, disposable);
+            }
+        }
+
+        MergeWithObserver(Observer<? super T> observer) {
+            this.a = observer;
+        }
+
+        void a(Throwable th) {
+            DisposableHelper.dispose(this.b);
+            HalfSerializer.a((Observer<?>) this.a, th, (AtomicInteger) this, this.d);
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            DisposableHelper.dispose(this.b);
+            DisposableHelper.dispose(this.c);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.e = true;
+            if (this.f) {
+                HalfSerializer.a(this.a, this, this.d);
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            DisposableHelper.dispose(this.b);
+            HalfSerializer.a((Observer<?>) this.a, th, (AtomicInteger) this, this.d);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            HalfSerializer.a(this.a, t, this, this.d);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            DisposableHelper.setOnce(this.b, disposable);
+        }
+
+        void a() {
+            this.f = true;
+            if (this.e) {
+                HalfSerializer.a(this.a, this, this.d);
+            }
+        }
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableMergeWithMaybe.java

@@ -0,0 +1,208 @@
+package io.reactivex.internal.operators.observable;
+
+import android.Manifest;
+import io.reactivex.MaybeObserver;
+import io.reactivex.MaybeSource;
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.fuseable.SimplePlainQueue;
+import io.reactivex.internal.queue.SpscLinkedArrayQueue;
+import io.reactivex.internal.util.AtomicThrowable;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableMergeWithMaybe<T> extends AbstractObservableWithUpstream<T, T> {
+    final MaybeSource<? extends T> b;
+
+    public ObservableMergeWithMaybe(Observable<T> observable, MaybeSource<? extends T> maybeSource) {
+        super(observable);
+        this.b = maybeSource;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super T> observer) {
+        MergeWithObserver mergeWithObserver = new MergeWithObserver(observer);
+        observer.onSubscribe(mergeWithObserver);
+        this.a.subscribe(mergeWithObserver);
+        this.b.a(mergeWithObserver.c);
+    }
+
+    static final class MergeWithObserver<T> extends AtomicInteger implements Observer<T>, Disposable {
+        final Observer<? super T> a;
+        final AtomicReference<Disposable> b = new AtomicReference<>();
+        final OtherObserver<T> c = new OtherObserver<>(this);
+        final AtomicThrowable d = new AtomicThrowable();
+        volatile SimplePlainQueue<T> e;
+        T f;
+        volatile boolean g;
+        volatile boolean h;
+        volatile int i;
+
+        static final class OtherObserver<T> extends AtomicReference<Disposable> implements MaybeObserver<T> {
+            final MergeWithObserver<T> a;
+
+            OtherObserver(MergeWithObserver<T> mergeWithObserver) {
+                this.a = mergeWithObserver;
+            }
+
+            @Override // io.reactivex.MaybeObserver
+            public void onComplete() {
+                this.a.d();
+            }
+
+            @Override // io.reactivex.MaybeObserver
+            public void onError(Throwable th) {
+                this.a.a(th);
+            }
+
+            @Override // io.reactivex.MaybeObserver
+            public void onSubscribe(Disposable disposable) {
+                DisposableHelper.setOnce(this, disposable);
+            }
+
+            @Override // io.reactivex.MaybeObserver
+            public void onSuccess(T t) {
+                this.a.a((MergeWithObserver<T>) t);
+            }
+        }
+
+        MergeWithObserver(Observer<? super T> observer) {
+            this.a = observer;
+        }
+
+        void a(T t) {
+            if (compareAndSet(0, 1)) {
+                this.a.onNext(t);
+                this.i = 2;
+            } else {
+                this.f = t;
+                this.i = 1;
+                if (getAndIncrement() != 0) {
+                    return;
+                }
+            }
+            b();
+        }
+
+        void b() {
+            Observer<? super T> observer = this.a;
+            int i = 1;
+            while (!this.g) {
+                if (this.d.get() != null) {
+                    this.f = null;
+                    this.e = null;
+                    observer.onError(this.d.terminate());
+                    return;
+                }
+                int i2 = this.i;
+                if (i2 == 1) {
+                    T t = this.f;
+                    this.f = null;
+                    this.i = 2;
+                    observer.onNext(t);
+                    i2 = 2;
+                }
+                boolean z = this.h;
+                SimplePlainQueue<T> simplePlainQueue = this.e;
+                Manifest poll = simplePlainQueue != null ? simplePlainQueue.poll() : null;
+                boolean z2 = poll == null;
+                if (z && z2 && i2 == 2) {
+                    this.e = null;
+                    observer.onComplete();
+                    return;
+                } else if (z2) {
+                    i = addAndGet(-i);
+                    if (i == 0) {
+                        return;
+                    }
+                } else {
+                    observer.onNext(poll);
+                }
+            }
+            this.f = null;
+            this.e = null;
+        }
+
+        SimplePlainQueue<T> c() {
+            SimplePlainQueue<T> simplePlainQueue = this.e;
+            if (simplePlainQueue != null) {
+                return simplePlainQueue;
+            }
+            SpscLinkedArrayQueue spscLinkedArrayQueue = new SpscLinkedArrayQueue(Observable.bufferSize());
+            this.e = spscLinkedArrayQueue;
+            return spscLinkedArrayQueue;
+        }
+
+        void d() {
+            this.i = 2;
+            a();
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.g = true;
+            DisposableHelper.dispose(this.b);
+            DisposableHelper.dispose(this.c);
+            if (getAndIncrement() == 0) {
+                this.e = null;
+                this.f = null;
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.h = true;
+            a();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (!this.d.addThrowable(th)) {
+                RxJavaPlugins.b(th);
+            } else {
+                DisposableHelper.dispose(this.b);
+                a();
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            if (compareAndSet(0, 1)) {
+                this.a.onNext(t);
+                if (decrementAndGet() == 0) {
+                    return;
+                }
+            } else {
+                c().offer(t);
+                if (getAndIncrement() != 0) {
+                    return;
+                }
+            }
+            b();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            DisposableHelper.setOnce(this.b, disposable);
+        }
+
+        void a(Throwable th) {
+            if (this.d.addThrowable(th)) {
+                DisposableHelper.dispose(this.b);
+                a();
+            } else {
+                RxJavaPlugins.b(th);
+            }
+        }
+
+        void a() {
+            if (getAndIncrement() == 0) {
+                b();
+            }
+        }
+    }
+}

sources/io/reactivex/internal/operators/observable/ObservableMergeWithSingle.java

@@ -0,0 +1,198 @@
+package io.reactivex.internal.operators.observable;
+
+import android.Manifest;
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.SingleObserver;
+import io.reactivex.SingleSource;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.fuseable.SimplePlainQueue;
+import io.reactivex.internal.queue.SpscLinkedArrayQueue;
+import io.reactivex.internal.util.AtomicThrowable;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ObservableMergeWithSingle<T> extends AbstractObservableWithUpstream<T, T> {
+    final SingleSource<? extends T> b;
+
+    public ObservableMergeWithSingle(Observable<T> observable, SingleSource<? extends T> singleSource) {
+        super(observable);
+        this.b = singleSource;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super T> observer) {
+        MergeWithObserver mergeWithObserver = new MergeWithObserver(observer);
+        observer.onSubscribe(mergeWithObserver);
+        this.a.subscribe(mergeWithObserver);
+        this.b.a(mergeWithObserver.c);
+    }
+
+    static final class MergeWithObserver<T> extends AtomicInteger implements Observer<T>, Disposable {
+        final Observer<? super T> a;
+        final AtomicReference<Disposable> b = new AtomicReference<>();
+        final OtherObserver<T> c = new OtherObserver<>(this);
+        final AtomicThrowable d = new AtomicThrowable();
+        volatile SimplePlainQueue<T> e;
+        T f;
+        volatile boolean g;
+        volatile boolean h;
+        volatile int i;
+
+        static final class OtherObserver<T> extends AtomicReference<Disposable> implements SingleObserver<T> {
+            final MergeWithObserver<T> a;
+
+            OtherObserver(MergeWithObserver<T> mergeWithObserver) {
+                this.a = mergeWithObserver;
+            }
+
+            @Override // io.reactivex.SingleObserver
+            public void onError(Throwable th) {
+                this.a.a(th);
+            }
+
+            @Override // io.reactivex.SingleObserver
+            public void onSubscribe(Disposable disposable) {
+                DisposableHelper.setOnce(this, disposable);
+            }
+
+            @Override // io.reactivex.SingleObserver
+            public void onSuccess(T t) {
+                this.a.a((MergeWithObserver<T>) t);
+            }
+        }
+
+        MergeWithObserver(Observer<? super T> observer) {
+            this.a = observer;
+        }
+
+        void a(T t) {
+            if (compareAndSet(0, 1)) {
+                this.a.onNext(t);
+                this.i = 2;
+            } else {
+                this.f = t;
+                this.i = 1;
+                if (getAndIncrement() != 0) {
+                    return;
+                }
+            }
+            b();
+        }
+
+        void b() {
+            Observer<? super T> observer = this.a;
+            int i = 1;
+            while (!this.g) {
+                if (this.d.get() != null) {
+                    this.f = null;
+                    this.e = null;
+                    observer.onError(this.d.terminate());
+                    return;
+                }
+                int i2 = this.i;
+                if (i2 == 1) {
+                    T t = this.f;
+                    this.f = null;
+                    this.i = 2;
+                    observer.onNext(t);
+                    i2 = 2;
+                }
+                boolean z = this.h;
+                SimplePlainQueue<T> simplePlainQueue = this.e;
+                Manifest poll = simplePlainQueue != null ? simplePlainQueue.poll() : null;
+                boolean z2 = poll == null;
+                if (z && z2 && i2 == 2) {
+                    this.e = null;
+                    observer.onComplete();
+                    return;
+                } else if (z2) {
+                    i = addAndGet(-i);
+                    if (i == 0) {
+                        return;
+                    }
+                } else {
+                    observer.onNext(poll);
+                }
+            }
+            this.f = null;
+            this.e = null;
+        }
+
+        SimplePlainQueue<T> c() {
+            SimplePlainQueue<T> simplePlainQueue = this.e;
+            if (simplePlainQueue != null) {
+                return simplePlainQueue;
+            }
+            SpscLinkedArrayQueue spscLinkedArrayQueue = new SpscLinkedArrayQueue(Observable.bufferSize());
+            this.e = spscLinkedArrayQueue;
+            return spscLinkedArrayQueue;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.g = true;
+            DisposableHelper.dispose(this.b);
+            DisposableHelper.dispose(this.c);
+            if (getAndIncrement() == 0) {
+                this.e = null;
+                this.f = null;
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.h = true;
+            a();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (!this.d.addThrowable(th)) {
+                RxJavaPlugins.b(th);
+            } else {
+                DisposableHelper.dispose(this.b);
+                a();
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(T t) {
+            if (compareAndSet(0, 1)) {
+                this.a.onNext(t);
+                if (decrementAndGet() == 0) {
+                    return;
+                }
+            } else {
+                c().offer(t);
+                if (getAndIncrement() != 0) {
+                    return;
+                }
+            }
+            b();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            DisposableHelper.setOnce(this.b, disposable);
+        }
+
+        void a(Throwable th) {
+            if (this.d.addThrowable(th)) {
+                DisposableHelper.dispose(this.b);
+                a();
+            } else {
+                RxJavaPlugins.b(th);
+            }
+        }
+
+        void a() {
+            if (getAndIncrement() == 0) {
+                b();
+            }
+        }
+    }
+}