Initial commit

sources/io/reactivex/internal/disposables/ArrayCompositeDisposable.java

@@ -0,0 +1,60 @@
+package io.reactivex.internal.disposables;
+
+import io.reactivex.disposables.Disposable;
+import java.util.concurrent.atomic.AtomicReferenceArray;
+
+/* loaded from: classes2.dex */
+public final class ArrayCompositeDisposable extends AtomicReferenceArray<Disposable> implements Disposable {
+    private static final long serialVersionUID = 2746389416410565408L;
+
+    public ArrayCompositeDisposable(int i) {
+        super(i);
+    }
+
+    @Override // io.reactivex.disposables.Disposable
+    public void dispose() {
+        Disposable andSet;
+        if (get(0) != DisposableHelper.DISPOSED) {
+            int length = length();
+            for (int i = 0; i < length; i++) {
+                Disposable disposable = get(i);
+                DisposableHelper disposableHelper = DisposableHelper.DISPOSED;
+                if (disposable != disposableHelper && (andSet = getAndSet(i, disposableHelper)) != DisposableHelper.DISPOSED && andSet != null) {
+                    andSet.dispose();
+                }
+            }
+        }
+    }
+
+    public boolean isDisposed() {
+        return get(0) == DisposableHelper.DISPOSED;
+    }
+
+    public Disposable replaceResource(int i, Disposable disposable) {
+        Disposable disposable2;
+        do {
+            disposable2 = get(i);
+            if (disposable2 == DisposableHelper.DISPOSED) {
+                disposable.dispose();
+                return null;
+            }
+        } while (!compareAndSet(i, disposable2, disposable));
+        return disposable2;
+    }
+
+    public boolean setResource(int i, Disposable disposable) {
+        Disposable disposable2;
+        do {
+            disposable2 = get(i);
+            if (disposable2 == DisposableHelper.DISPOSED) {
+                disposable.dispose();
+                return false;
+            }
+        } while (!compareAndSet(i, disposable2, disposable));
+        if (disposable2 == null) {
+            return true;
+        }
+        disposable2.dispose();
+        return true;
+    }
+}

sources/io/reactivex/internal/disposables/CancellableDisposable.java

@@ -0,0 +1,34 @@
+package io.reactivex.internal.disposables;
+
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Cancellable;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class CancellableDisposable extends AtomicReference<Cancellable> implements Disposable {
+    private static final long serialVersionUID = 5718521705281392066L;
+
+    public CancellableDisposable(Cancellable cancellable) {
+        super(cancellable);
+    }
+
+    @Override // io.reactivex.disposables.Disposable
+    public void dispose() {
+        Cancellable andSet;
+        if (get() == null || (andSet = getAndSet(null)) == null) {
+            return;
+        }
+        try {
+            andSet.cancel();
+        } catch (Exception e) {
+            Exceptions.b(e);
+            RxJavaPlugins.b(e);
+        }
+    }
+
+    public boolean isDisposed() {
+        return get() == null;
+    }
+}

sources/io/reactivex/internal/disposables/DisposableContainer.java

@@ -0,0 +1,12 @@
+package io.reactivex.internal.disposables;
+
+import io.reactivex.disposables.Disposable;
+
+/* loaded from: classes2.dex */
+public interface DisposableContainer {
+    boolean a(Disposable disposable);
+
+    boolean b(Disposable disposable);
+
+    boolean c(Disposable disposable);
+}

sources/io/reactivex/internal/disposables/DisposableHelper.java

@@ -0,0 +1,113 @@
+package io.reactivex.internal.disposables;
+
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.ProtocolViolationException;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public enum DisposableHelper implements Disposable {
+    DISPOSED;
+
+    public static boolean dispose(AtomicReference<Disposable> atomicReference) {
+        Disposable andSet;
+        Disposable disposable = atomicReference.get();
+        DisposableHelper disposableHelper = DISPOSED;
+        if (disposable == disposableHelper || (andSet = atomicReference.getAndSet(disposableHelper)) == disposableHelper) {
+            return false;
+        }
+        if (andSet == null) {
+            return true;
+        }
+        andSet.dispose();
+        return true;
+    }
+
+    public static boolean isDisposed(Disposable disposable) {
+        return disposable == DISPOSED;
+    }
+
+    public static boolean replace(AtomicReference<Disposable> atomicReference, Disposable disposable) {
+        Disposable disposable2;
+        do {
+            disposable2 = atomicReference.get();
+            if (disposable2 == DISPOSED) {
+                if (disposable == null) {
+                    return false;
+                }
+                disposable.dispose();
+                return false;
+            }
+        } while (!atomicReference.compareAndSet(disposable2, disposable));
+        return true;
+    }
+
+    public static void reportDisposableSet() {
+        RxJavaPlugins.b(new ProtocolViolationException("Disposable already set!"));
+    }
+
+    public static boolean set(AtomicReference<Disposable> atomicReference, Disposable disposable) {
+        Disposable disposable2;
+        do {
+            disposable2 = atomicReference.get();
+            if (disposable2 == DISPOSED) {
+                if (disposable == null) {
+                    return false;
+                }
+                disposable.dispose();
+                return false;
+            }
+        } while (!atomicReference.compareAndSet(disposable2, disposable));
+        if (disposable2 == null) {
+            return true;
+        }
+        disposable2.dispose();
+        return true;
+    }
+
+    public static boolean setOnce(AtomicReference<Disposable> atomicReference, Disposable disposable) {
+        ObjectHelper.a(disposable, "d is null");
+        if (atomicReference.compareAndSet(null, disposable)) {
+            return true;
+        }
+        disposable.dispose();
+        if (atomicReference.get() == DISPOSED) {
+            return false;
+        }
+        reportDisposableSet();
+        return false;
+    }
+
+    public static boolean trySet(AtomicReference<Disposable> atomicReference, Disposable disposable) {
+        if (atomicReference.compareAndSet(null, disposable)) {
+            return true;
+        }
+        if (atomicReference.get() != DISPOSED) {
+            return false;
+        }
+        disposable.dispose();
+        return false;
+    }
+
+    public static boolean validate(Disposable disposable, Disposable disposable2) {
+        if (disposable2 == null) {
+            RxJavaPlugins.b(new NullPointerException("next is null"));
+            return false;
+        }
+        if (disposable == null) {
+            return true;
+        }
+        disposable2.dispose();
+        reportDisposableSet();
+        return false;
+    }
+
+    @Override // io.reactivex.disposables.Disposable
+    public void dispose() {
+    }
+
+    public boolean isDisposed() {
+        return true;
+    }
+}

sources/io/reactivex/internal/disposables/EmptyDisposable.java

@@ -0,0 +1,84 @@
+package io.reactivex.internal.disposables;
+
+import io.reactivex.CompletableObserver;
+import io.reactivex.MaybeObserver;
+import io.reactivex.Observer;
+import io.reactivex.SingleObserver;
+import io.reactivex.internal.fuseable.QueueDisposable;
+
+/* loaded from: classes2.dex */
+public enum EmptyDisposable implements QueueDisposable<Object> {
+    INSTANCE,
+    NEVER;
+
+    public static void complete(Observer<?> observer) {
+        observer.onSubscribe(INSTANCE);
+        observer.onComplete();
+    }
+
+    public static void error(Throwable th, Observer<?> observer) {
+        observer.onSubscribe(INSTANCE);
+        observer.onError(th);
+    }
+
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public void clear() {
+    }
+
+    @Override // io.reactivex.disposables.Disposable
+    public void dispose() {
+    }
+
+    public boolean isDisposed() {
+        return this == INSTANCE;
+    }
+
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public boolean isEmpty() {
+        return true;
+    }
+
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public boolean offer(Object obj) {
+        throw new UnsupportedOperationException("Should not be called!");
+    }
+
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public Object poll() throws Exception {
+        return null;
+    }
+
+    @Override // io.reactivex.internal.fuseable.QueueFuseable
+    public int requestFusion(int i) {
+        return i & 2;
+    }
+
+    public boolean offer(Object obj, Object obj2) {
+        throw new UnsupportedOperationException("Should not be called!");
+    }
+
+    public static void complete(MaybeObserver<?> maybeObserver) {
+        maybeObserver.onSubscribe(INSTANCE);
+        maybeObserver.onComplete();
+    }
+
+    public static void error(Throwable th, CompletableObserver completableObserver) {
+        completableObserver.onSubscribe(INSTANCE);
+        completableObserver.onError(th);
+    }
+
+    public static void complete(CompletableObserver completableObserver) {
+        completableObserver.onSubscribe(INSTANCE);
+        completableObserver.onComplete();
+    }
+
+    public static void error(Throwable th, SingleObserver<?> singleObserver) {
+        singleObserver.onSubscribe(INSTANCE);
+        singleObserver.onError(th);
+    }
+
+    public static void error(Throwable th, MaybeObserver<?> maybeObserver) {
+        maybeObserver.onSubscribe(INSTANCE);
+        maybeObserver.onError(th);
+    }
+}

sources/io/reactivex/internal/disposables/ListCompositeDisposable.java

@@ -0,0 +1,105 @@
+package io.reactivex.internal.disposables;
+
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.CompositeException;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.util.ExceptionHelper;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+/* loaded from: classes2.dex */
+public final class ListCompositeDisposable implements Disposable, DisposableContainer {
+    List<Disposable> a;
+    volatile boolean b;
+
+    @Override // io.reactivex.internal.disposables.DisposableContainer
+    public boolean a(Disposable disposable) {
+        if (!c(disposable)) {
+            return false;
+        }
+        disposable.dispose();
+        return true;
+    }
+
+    @Override // io.reactivex.internal.disposables.DisposableContainer
+    public boolean b(Disposable disposable) {
+        ObjectHelper.a(disposable, "d is null");
+        if (!this.b) {
+            synchronized (this) {
+                if (!this.b) {
+                    List list = this.a;
+                    if (list == null) {
+                        list = new LinkedList();
+                        this.a = list;
+                    }
+                    list.add(disposable);
+                    return true;
+                }
+            }
+        }
+        disposable.dispose();
+        return false;
+    }
+
+    @Override // io.reactivex.internal.disposables.DisposableContainer
+    public boolean c(Disposable disposable) {
+        ObjectHelper.a(disposable, "Disposable item is null");
+        if (this.b) {
+            return false;
+        }
+        synchronized (this) {
+            if (this.b) {
+                return false;
+            }
+            List<Disposable> list = this.a;
+            if (list != null && list.remove(disposable)) {
+                return true;
+            }
+            return false;
+        }
+    }
+
+    @Override // io.reactivex.disposables.Disposable
+    public void dispose() {
+        if (this.b) {
+            return;
+        }
+        synchronized (this) {
+            if (this.b) {
+                return;
+            }
+            this.b = true;
+            List<Disposable> list = this.a;
+            this.a = null;
+            a(list);
+        }
+    }
+
+    void a(List<Disposable> list) {
+        if (list == null) {
+            return;
+        }
+        ArrayList arrayList = null;
+        Iterator<Disposable> it = list.iterator();
+        while (it.hasNext()) {
+            try {
+                it.next().dispose();
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                if (arrayList == null) {
+                    arrayList = new ArrayList();
+                }
+                arrayList.add(th);
+            }
+        }
+        if (arrayList != null) {
+            if (arrayList.size() == 1) {
+                throw ExceptionHelper.a((Throwable) arrayList.get(0));
+            }
+            throw new CompositeException(arrayList);
+        }
+    }
+}

sources/io/reactivex/internal/disposables/ResettableConnectable.java

@@ -0,0 +1,8 @@
+package io.reactivex.internal.disposables;
+
+import io.reactivex.disposables.Disposable;
+
+/* loaded from: classes2.dex */
+public interface ResettableConnectable {
+    void a(Disposable disposable);
+}

sources/io/reactivex/internal/disposables/SequentialDisposable.java

@@ -0,0 +1,33 @@
+package io.reactivex.internal.disposables;
+
+import io.reactivex.disposables.Disposable;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class SequentialDisposable extends AtomicReference<Disposable> implements Disposable {
+    private static final long serialVersionUID = -754898800686245608L;
+
+    public SequentialDisposable() {
+    }
+
+    @Override // io.reactivex.disposables.Disposable
+    public void dispose() {
+        DisposableHelper.dispose(this);
+    }
+
+    public boolean isDisposed() {
+        return DisposableHelper.isDisposed(get());
+    }
+
+    public boolean replace(Disposable disposable) {
+        return DisposableHelper.replace(this, disposable);
+    }
+
+    public boolean update(Disposable disposable) {
+        return DisposableHelper.set(this, disposable);
+    }
+
+    public SequentialDisposable(Disposable disposable) {
+        lazySet(disposable);
+    }
+}

sources/io/reactivex/internal/functions/Functions.java

@@ -0,0 +1,728 @@
+package io.reactivex.internal.functions;
+
+import io.reactivex.Notification;
+import io.reactivex.Scheduler;
+import io.reactivex.exceptions.OnErrorNotImplementedException;
+import io.reactivex.functions.Action;
+import io.reactivex.functions.BiConsumer;
+import io.reactivex.functions.BiFunction;
+import io.reactivex.functions.BooleanSupplier;
+import io.reactivex.functions.Consumer;
+import io.reactivex.functions.Function;
+import io.reactivex.functions.Function3;
+import io.reactivex.functions.Function4;
+import io.reactivex.functions.Function5;
+import io.reactivex.functions.Function6;
+import io.reactivex.functions.Function7;
+import io.reactivex.functions.Function8;
+import io.reactivex.functions.Function9;
+import io.reactivex.functions.LongConsumer;
+import io.reactivex.functions.Predicate;
+import io.reactivex.plugins.RxJavaPlugins;
+import io.reactivex.schedulers.Timed;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.Callable;
+import java.util.concurrent.TimeUnit;
+import org.reactivestreams.Subscription;
+
+/* loaded from: classes2.dex */
+public final class Functions {
+    static final Function<Object, Object> a = new Identity();
+    public static final Runnable b = new EmptyRunnable();
+    public static final Action c = new EmptyAction();
+    static final Consumer<Object> d = new EmptyConsumer();
+    public static final Consumer<Throwable> e;
+    static final Predicate<Object> f;
+    static final Predicate<Object> g;
+    static final Callable<Object> h;
+    static final Comparator<Object> i;
+
+    static final class ActionConsumer<T> implements Consumer<T> {
+        final Action a;
+
+        ActionConsumer(Action action) {
+            this.a = action;
+        }
+
+        @Override // io.reactivex.functions.Consumer
+        public void accept(T t) throws Exception {
+            this.a.run();
+        }
+    }
+
+    static final class Array2Func<T1, T2, R> implements Function<Object[], R> {
+        final BiFunction<? super T1, ? super T2, ? extends R> a;
+
+        Array2Func(BiFunction<? super T1, ? super T2, ? extends R> biFunction) {
+            this.a = biFunction;
+        }
+
+        @Override // io.reactivex.functions.Function
+        /* renamed from: a, reason: merged with bridge method [inline-methods] */
+        public R apply(Object[] objArr) throws Exception {
+            if (objArr.length == 2) {
+                return this.a.apply(objArr[0], objArr[1]);
+            }
+            throw new IllegalArgumentException("Array of size 2 expected but got " + objArr.length);
+        }
+    }
+
+    static final class Array3Func<T1, T2, T3, R> implements Function<Object[], R> {
+        final Function3<T1, T2, T3, R> a;
+
+        Array3Func(Function3<T1, T2, T3, R> function3) {
+            this.a = function3;
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // io.reactivex.functions.Function
+        /* renamed from: a, reason: merged with bridge method [inline-methods] */
+        public R apply(Object[] objArr) throws Exception {
+            if (objArr.length == 3) {
+                return (R) this.a.apply(objArr[0], objArr[1], objArr[2]);
+            }
+            throw new IllegalArgumentException("Array of size 3 expected but got " + objArr.length);
+        }
+    }
+
+    static final class Array4Func<T1, T2, T3, T4, R> implements Function<Object[], R> {
+        final Function4<T1, T2, T3, T4, R> a;
+
+        Array4Func(Function4<T1, T2, T3, T4, R> function4) {
+            this.a = function4;
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // io.reactivex.functions.Function
+        /* renamed from: a, reason: merged with bridge method [inline-methods] */
+        public R apply(Object[] objArr) throws Exception {
+            if (objArr.length == 4) {
+                return (R) this.a.a(objArr[0], objArr[1], objArr[2], objArr[3]);
+            }
+            throw new IllegalArgumentException("Array of size 4 expected but got " + objArr.length);
+        }
+    }
+
+    static final class Array5Func<T1, T2, T3, T4, T5, R> implements Function<Object[], R> {
+        private final Function5<T1, T2, T3, T4, T5, R> a;
+
+        Array5Func(Function5<T1, T2, T3, T4, T5, R> function5) {
+            this.a = function5;
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // io.reactivex.functions.Function
+        /* renamed from: a, reason: merged with bridge method [inline-methods] */
+        public R apply(Object[] objArr) throws Exception {
+            if (objArr.length == 5) {
+                return (R) this.a.a(objArr[0], objArr[1], objArr[2], objArr[3], objArr[4]);
+            }
+            throw new IllegalArgumentException("Array of size 5 expected but got " + objArr.length);
+        }
+    }
+
+    static final class Array6Func<T1, T2, T3, T4, T5, T6, R> implements Function<Object[], R> {
+        final Function6<T1, T2, T3, T4, T5, T6, R> a;
+
+        Array6Func(Function6<T1, T2, T3, T4, T5, T6, R> function6) {
+            this.a = function6;
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // io.reactivex.functions.Function
+        /* renamed from: a, reason: merged with bridge method [inline-methods] */
+        public R apply(Object[] objArr) throws Exception {
+            if (objArr.length == 6) {
+                return (R) this.a.a(objArr[0], objArr[1], objArr[2], objArr[3], objArr[4], objArr[5]);
+            }
+            throw new IllegalArgumentException("Array of size 6 expected but got " + objArr.length);
+        }
+    }
+
+    static final class Array7Func<T1, T2, T3, T4, T5, T6, T7, R> implements Function<Object[], R> {
+        final Function7<T1, T2, T3, T4, T5, T6, T7, R> a;
+
+        Array7Func(Function7<T1, T2, T3, T4, T5, T6, T7, R> function7) {
+            this.a = function7;
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // io.reactivex.functions.Function
+        /* renamed from: a, reason: merged with bridge method [inline-methods] */
+        public R apply(Object[] objArr) throws Exception {
+            if (objArr.length == 7) {
+                return (R) this.a.a(objArr[0], objArr[1], objArr[2], objArr[3], objArr[4], objArr[5], objArr[6]);
+            }
+            throw new IllegalArgumentException("Array of size 7 expected but got " + objArr.length);
+        }
+    }
+
+    static final class Array8Func<T1, T2, T3, T4, T5, T6, T7, T8, R> implements Function<Object[], R> {
+        final Function8<T1, T2, T3, T4, T5, T6, T7, T8, R> a;
+
+        Array8Func(Function8<T1, T2, T3, T4, T5, T6, T7, T8, R> function8) {
+            this.a = function8;
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // io.reactivex.functions.Function
+        /* renamed from: a, reason: merged with bridge method [inline-methods] */
+        public R apply(Object[] objArr) throws Exception {
+            if (objArr.length == 8) {
+                return (R) this.a.a(objArr[0], objArr[1], objArr[2], objArr[3], objArr[4], objArr[5], objArr[6], objArr[7]);
+            }
+            throw new IllegalArgumentException("Array of size 8 expected but got " + objArr.length);
+        }
+    }
+
+    static final class Array9Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, R> implements Function<Object[], R> {
+        final Function9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R> a;
+
+        Array9Func(Function9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R> function9) {
+            this.a = function9;
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // io.reactivex.functions.Function
+        /* renamed from: a, reason: merged with bridge method [inline-methods] */
+        public R apply(Object[] objArr) throws Exception {
+            if (objArr.length == 9) {
+                return (R) this.a.a(objArr[0], objArr[1], objArr[2], objArr[3], objArr[4], objArr[5], objArr[6], objArr[7], objArr[8]);
+            }
+            throw new IllegalArgumentException("Array of size 9 expected but got " + objArr.length);
+        }
+    }
+
+    static final class ArrayListCapacityCallable<T> implements Callable<List<T>> {
+        final int a;
+
+        ArrayListCapacityCallable(int i) {
+            this.a = i;
+        }
+
+        @Override // java.util.concurrent.Callable
+        public List<T> call() throws Exception {
+            return new ArrayList(this.a);
+        }
+    }
+
+    static final class BooleanSupplierPredicateReverse<T> implements Predicate<T> {
+        final BooleanSupplier a;
+
+        BooleanSupplierPredicateReverse(BooleanSupplier booleanSupplier) {
+            this.a = booleanSupplier;
+        }
+
+        @Override // io.reactivex.functions.Predicate
+        public boolean a(T t) throws Exception {
+            return !this.a.a();
+        }
+    }
+
+    static final class CastToClass<T, U> implements Function<T, U> {
+        final Class<U> a;
+
+        CastToClass(Class<U> cls) {
+            this.a = cls;
+        }
+
+        @Override // io.reactivex.functions.Function
+        public U apply(T t) throws Exception {
+            return this.a.cast(t);
+        }
+    }
+
+    static final class ClassFilter<T, U> implements Predicate<T> {
+        final Class<U> a;
+
+        ClassFilter(Class<U> cls) {
+            this.a = cls;
+        }
+
+        @Override // io.reactivex.functions.Predicate
+        public boolean a(T t) throws Exception {
+            return this.a.isInstance(t);
+        }
+    }
+
+    static final class EmptyAction implements Action {
+        EmptyAction() {
+        }
+
+        @Override // io.reactivex.functions.Action
+        public void run() {
+        }
+
+        public String toString() {
+            return "EmptyAction";
+        }
+    }
+
+    static final class EmptyConsumer implements Consumer<Object> {
+        EmptyConsumer() {
+        }
+
+        @Override // io.reactivex.functions.Consumer
+        public void accept(Object obj) {
+        }
+
+        public String toString() {
+            return "EmptyConsumer";
+        }
+    }
+
+    static final class EmptyLongConsumer implements LongConsumer {
+        EmptyLongConsumer() {
+        }
+    }
+
+    static final class EmptyRunnable implements Runnable {
+        EmptyRunnable() {
+        }
+
+        @Override // java.lang.Runnable
+        public void run() {
+        }
+
+        public String toString() {
+            return "EmptyRunnable";
+        }
+    }
+
+    static final class EqualsPredicate<T> implements Predicate<T> {
+        final T a;
+
+        EqualsPredicate(T t) {
+            this.a = t;
+        }
+
+        @Override // io.reactivex.functions.Predicate
+        public boolean a(T t) throws Exception {
+            return ObjectHelper.a(t, this.a);
+        }
+    }
+
+    static final class ErrorConsumer implements Consumer<Throwable> {
+        ErrorConsumer() {
+        }
+
+        @Override // io.reactivex.functions.Consumer
+        /* renamed from: a, reason: merged with bridge method [inline-methods] */
+        public void accept(Throwable th) {
+            RxJavaPlugins.b(th);
+        }
+    }
+
+    static final class FalsePredicate implements Predicate<Object> {
+        FalsePredicate() {
+        }
+
+        @Override // io.reactivex.functions.Predicate
+        public boolean a(Object obj) {
+            return false;
+        }
+    }
+
+    enum HashSetCallable implements Callable<Set<Object>> {
+        INSTANCE;
+
+        @Override // java.util.concurrent.Callable
+        public Set<Object> call() throws Exception {
+            return new HashSet();
+        }
+    }
+
+    static final class Identity implements Function<Object, Object> {
+        Identity() {
+        }
+
+        @Override // io.reactivex.functions.Function
+        public Object apply(Object obj) {
+            return obj;
+        }
+
+        public String toString() {
+            return "IdentityFunction";
+        }
+    }
+
+    static final class JustValue<T, U> implements Callable<U>, Function<T, U> {
+        final U a;
+
+        JustValue(U u) {
+            this.a = u;
+        }
+
+        @Override // io.reactivex.functions.Function
+        public U apply(T t) throws Exception {
+            return this.a;
+        }
+
+        @Override // java.util.concurrent.Callable
+        public U call() throws Exception {
+            return this.a;
+        }
+    }
+
+    static final class ListSorter<T> implements Function<List<T>, List<T>> {
+        final Comparator<? super T> a;
+
+        ListSorter(Comparator<? super T> comparator) {
+            this.a = comparator;
+        }
+
+        public List<T> a(List<T> list) {
+            Collections.sort(list, this.a);
+            return list;
+        }
+
+        @Override // io.reactivex.functions.Function
+        public /* bridge */ /* synthetic */ Object apply(Object obj) throws Exception {
+            List<T> list = (List) obj;
+            a(list);
+            return list;
+        }
+    }
+
+    static final class MaxRequestSubscription implements Consumer<Subscription> {
+        MaxRequestSubscription() {
+        }
+
+        @Override // io.reactivex.functions.Consumer
+        /* renamed from: a, reason: merged with bridge method [inline-methods] */
+        public void accept(Subscription subscription) throws Exception {
+            subscription.request(Long.MAX_VALUE);
+        }
+    }
+
+    enum NaturalComparator implements Comparator<Object> {
+        INSTANCE;
+
+        @Override // java.util.Comparator
+        public int compare(Object obj, Object obj2) {
+            return ((Comparable) obj).compareTo(obj2);
+        }
+    }
+
+    static final class NaturalObjectComparator implements Comparator<Object> {
+        NaturalObjectComparator() {
+        }
+
+        @Override // java.util.Comparator
+        public int compare(Object obj, Object obj2) {
+            return ((Comparable) obj).compareTo(obj2);
+        }
+    }
+
+    static final class NotificationOnComplete<T> implements Action {
+        final Consumer<? super Notification<T>> a;
+
+        NotificationOnComplete(Consumer<? super Notification<T>> consumer) {
+            this.a = consumer;
+        }
+
+        @Override // io.reactivex.functions.Action
+        public void run() throws Exception {
+            this.a.accept(Notification.f());
+        }
+    }
+
+    static final class NotificationOnError<T> implements Consumer<Throwable> {
+        final Consumer<? super Notification<T>> a;
+
+        NotificationOnError(Consumer<? super Notification<T>> consumer) {
+            this.a = consumer;
+        }
+
+        @Override // io.reactivex.functions.Consumer
+        /* renamed from: a, reason: merged with bridge method [inline-methods] */
+        public void accept(Throwable th) throws Exception {
+            this.a.accept(Notification.a(th));
+        }
+    }
+
+    static final class NotificationOnNext<T> implements Consumer<T> {
+        final Consumer<? super Notification<T>> a;
+
+        NotificationOnNext(Consumer<? super Notification<T>> consumer) {
+            this.a = consumer;
+        }
+
+        @Override // io.reactivex.functions.Consumer
+        public void accept(T t) throws Exception {
+            this.a.accept(Notification.a(t));
+        }
+    }
+
+    static final class NullCallable implements Callable<Object> {
+        NullCallable() {
+        }
+
+        @Override // java.util.concurrent.Callable
+        public Object call() {
+            return null;
+        }
+    }
+
+    static final class OnErrorMissingConsumer implements Consumer<Throwable> {
+        OnErrorMissingConsumer() {
+        }
+
+        @Override // io.reactivex.functions.Consumer
+        /* renamed from: a, reason: merged with bridge method [inline-methods] */
+        public void accept(Throwable th) {
+            RxJavaPlugins.b(new OnErrorNotImplementedException(th));
+        }
+    }
+
+    static final class TimestampFunction<T> implements Function<T, Timed<T>> {
+        final TimeUnit a;
+        final Scheduler b;
+
+        TimestampFunction(TimeUnit timeUnit, Scheduler scheduler) {
+            this.a = timeUnit;
+            this.b = scheduler;
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // io.reactivex.functions.Function
+        public /* bridge */ /* synthetic */ Object apply(Object obj) throws Exception {
+            return apply((TimestampFunction<T>) obj);
+        }
+
+        @Override // io.reactivex.functions.Function
+        public Timed<T> apply(T t) throws Exception {
+            return new Timed<>(t, this.b.a(this.a), this.a);
+        }
+    }
+
+    static final class ToMapKeySelector<K, T> implements BiConsumer<Map<K, T>, T> {
+        private final Function<? super T, ? extends K> a;
+
+        ToMapKeySelector(Function<? super T, ? extends K> function) {
+            this.a = function;
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // io.reactivex.functions.BiConsumer
+        public /* bridge */ /* synthetic */ void a(Object obj, Object obj2) throws Exception {
+            a((Map<K, Map<K, T>>) obj, (Map<K, T>) obj2);
+        }
+
+        public void a(Map<K, T> map, T t) throws Exception {
+            map.put(this.a.apply(t), t);
+        }
+    }
+
+    static final class ToMapKeyValueSelector<K, V, T> implements BiConsumer<Map<K, V>, T> {
+        private final Function<? super T, ? extends V> a;
+        private final Function<? super T, ? extends K> b;
+
+        ToMapKeyValueSelector(Function<? super T, ? extends V> function, Function<? super T, ? extends K> function2) {
+            this.a = function;
+            this.b = function2;
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // io.reactivex.functions.BiConsumer
+        public /* bridge */ /* synthetic */ void a(Object obj, Object obj2) throws Exception {
+            a((Map) obj, (Map<K, V>) obj2);
+        }
+
+        public void a(Map<K, V> map, T t) throws Exception {
+            map.put(this.b.apply(t), this.a.apply(t));
+        }
+    }
+
+    static final class ToMultimapKeyValueSelector<K, V, T> implements BiConsumer<Map<K, Collection<V>>, T> {
+        private final Function<? super K, ? extends Collection<? super V>> a;
+        private final Function<? super T, ? extends V> b;
+        private final Function<? super T, ? extends K> c;
+
+        ToMultimapKeyValueSelector(Function<? super K, ? extends Collection<? super V>> function, Function<? super T, ? extends V> function2, Function<? super T, ? extends K> function3) {
+            this.a = function;
+            this.b = function2;
+            this.c = function3;
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // io.reactivex.functions.BiConsumer
+        public /* bridge */ /* synthetic */ void a(Object obj, Object obj2) throws Exception {
+            a((Map) obj, (Map<K, Collection<V>>) obj2);
+        }
+
+        public void a(Map<K, Collection<V>> map, T t) throws Exception {
+            K apply = this.c.apply(t);
+            Collection<? super V> collection = (Collection) map.get(apply);
+            if (collection == null) {
+                collection = this.a.apply(apply);
+                map.put(apply, collection);
+            }
+            collection.add(this.b.apply(t));
+        }
+    }
+
+    static final class TruePredicate implements Predicate<Object> {
+        TruePredicate() {
+        }
+
+        @Override // io.reactivex.functions.Predicate
+        public boolean a(Object obj) {
+            return true;
+        }
+    }
+
+    static {
+        new ErrorConsumer();
+        e = new OnErrorMissingConsumer();
+        new EmptyLongConsumer();
+        f = new TruePredicate();
+        g = new FalsePredicate();
+        h = new NullCallable();
+        i = new NaturalObjectComparator();
+        new MaxRequestSubscription();
+    }
+
+    public static <T1, T2, R> Function<Object[], R> a(BiFunction<? super T1, ? super T2, ? extends R> biFunction) {
+        ObjectHelper.a(biFunction, "f is null");
+        return new Array2Func(biFunction);
+    }
+
+    public static <T> Predicate<T> b() {
+        return (Predicate<T>) f;
+    }
+
+    public static <T, U> Function<T, U> c(U u) {
+        return new JustValue(u);
+    }
+
+    public static <T> Consumer<T> d() {
+        return (Consumer<T>) d;
+    }
+
+    public static <T> Function<T, T> e() {
+        return (Function<T, T>) a;
+    }
+
+    public static <T> Comparator<T> f() {
+        return NaturalComparator.INSTANCE;
+    }
+
+    public static <T> Comparator<T> g() {
+        return (Comparator<T>) i;
+    }
+
+    public static <T> Callable<T> h() {
+        return (Callable<T>) h;
+    }
+
+    public static <T> Callable<T> b(T t) {
+        return new JustValue(t);
+    }
+
+    public static <T> Callable<Set<T>> c() {
+        return HashSetCallable.INSTANCE;
+    }
+
+    public static <T1, T2, T3, R> Function<Object[], R> a(Function3<T1, T2, T3, R> function3) {
+        ObjectHelper.a(function3, "f is null");
+        return new Array3Func(function3);
+    }
+
+    public static <T> Consumer<Throwable> b(Consumer<? super Notification<T>> consumer) {
+        return new NotificationOnError(consumer);
+    }
+
+    public static <T> Consumer<T> c(Consumer<? super Notification<T>> consumer) {
+        return new NotificationOnNext(consumer);
+    }
+
+    public static <T, U> Predicate<T> b(Class<U> cls) {
+        return new ClassFilter(cls);
+    }
+
+    public static <T1, T2, T3, T4, R> Function<Object[], R> a(Function4<T1, T2, T3, T4, R> function4) {
+        ObjectHelper.a(function4, "f is null");
+        return new Array4Func(function4);
+    }
+
+    public static <T1, T2, T3, T4, T5, R> Function<Object[], R> a(Function5<T1, T2, T3, T4, T5, R> function5) {
+        ObjectHelper.a(function5, "f is null");
+        return new Array5Func(function5);
+    }
+
+    public static <T1, T2, T3, T4, T5, T6, R> Function<Object[], R> a(Function6<T1, T2, T3, T4, T5, T6, R> function6) {
+        ObjectHelper.a(function6, "f is null");
+        return new Array6Func(function6);
+    }
+
+    public static <T1, T2, T3, T4, T5, T6, T7, R> Function<Object[], R> a(Function7<T1, T2, T3, T4, T5, T6, T7, R> function7) {
+        ObjectHelper.a(function7, "f is null");
+        return new Array7Func(function7);
+    }
+
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, R> Function<Object[], R> a(Function8<T1, T2, T3, T4, T5, T6, T7, T8, R> function8) {
+        ObjectHelper.a(function8, "f is null");
+        return new Array8Func(function8);
+    }
+
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Function<Object[], R> a(Function9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R> function9) {
+        ObjectHelper.a(function9, "f is null");
+        return new Array9Func(function9);
+    }
+
+    public static <T> Predicate<T> a() {
+        return (Predicate<T>) g;
+    }
+
+    public static <T, U> Function<T, U> a(Class<U> cls) {
+        return new CastToClass(cls);
+    }
+
+    public static <T> Callable<List<T>> a(int i2) {
+        return new ArrayListCapacityCallable(i2);
+    }
+
+    public static <T> Predicate<T> a(T t) {
+        return new EqualsPredicate(t);
+    }
+
+    public static <T> Action a(Consumer<? super Notification<T>> consumer) {
+        return new NotificationOnComplete(consumer);
+    }
+
+    public static <T> Consumer<T> a(Action action) {
+        return new ActionConsumer(action);
+    }
+
+    public static <T> Predicate<T> a(BooleanSupplier booleanSupplier) {
+        return new BooleanSupplierPredicateReverse(booleanSupplier);
+    }
+
+    public static <T> Function<T, Timed<T>> a(TimeUnit timeUnit, Scheduler scheduler) {
+        return new TimestampFunction(timeUnit, scheduler);
+    }
+
+    public static <T, K> BiConsumer<Map<K, T>, T> a(Function<? super T, ? extends K> function) {
+        return new ToMapKeySelector(function);
+    }
+
+    public static <T, K, V> BiConsumer<Map<K, V>, T> a(Function<? super T, ? extends K> function, Function<? super T, ? extends V> function2) {
+        return new ToMapKeyValueSelector(function2, function);
+    }
+
+    public static <T, K, V> BiConsumer<Map<K, Collection<V>>, T> a(Function<? super T, ? extends K> function, Function<? super T, ? extends V> function2, Function<? super K, ? extends Collection<? super V>> function3) {
+        return new ToMultimapKeyValueSelector(function3, function2, function);
+    }
+
+    public static <T> Function<List<T>, List<T>> a(Comparator<? super T> comparator) {
+        return new ListSorter(comparator);
+    }
+}

sources/io/reactivex/internal/functions/ObjectHelper.java

@@ -0,0 +1,61 @@
+package io.reactivex.internal.functions;
+
+import io.reactivex.functions.BiPredicate;
+
+/* loaded from: classes2.dex */
+public final class ObjectHelper {
+    static final BiPredicate<Object, Object> a = new BiObjectPredicate();
+
+    static final class BiObjectPredicate implements BiPredicate<Object, Object> {
+        BiObjectPredicate() {
+        }
+
+        @Override // io.reactivex.functions.BiPredicate
+        public boolean a(Object obj, Object obj2) {
+            return ObjectHelper.a(obj, obj2);
+        }
+    }
+
+    public static int a(int i, int i2) {
+        if (i < i2) {
+            return -1;
+        }
+        return i > i2 ? 1 : 0;
+    }
+
+    public static int a(long j, long j2) {
+        if (j < j2) {
+            return -1;
+        }
+        return j > j2 ? 1 : 0;
+    }
+
+    public static <T> T a(T t, String str) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException(str);
+    }
+
+    public static boolean a(Object obj, Object obj2) {
+        return obj == obj2 || (obj != null && obj.equals(obj2));
+    }
+
+    public static <T> BiPredicate<T, T> a() {
+        return (BiPredicate<T, T>) a;
+    }
+
+    public static int a(int i, String str) {
+        if (i > 0) {
+            return i;
+        }
+        throw new IllegalArgumentException(str + " > 0 required but it was " + i);
+    }
+
+    public static long a(long j, String str) {
+        if (j > 0) {
+            return j;
+        }
+        throw new IllegalArgumentException(str + " > 0 required but it was " + j);
+    }
+}

sources/io/reactivex/internal/fuseable/FuseToObservable.java

@@ -0,0 +1,8 @@
+package io.reactivex.internal.fuseable;
+
+import io.reactivex.Observable;
+
+/* loaded from: classes2.dex */
+public interface FuseToObservable<T> {
+    Observable<T> a();
+}

sources/io/reactivex/internal/fuseable/HasUpstreamMaybeSource.java

@@ -0,0 +1,5 @@
+package io.reactivex.internal.fuseable;
+
+/* loaded from: classes2.dex */
+public interface HasUpstreamMaybeSource<T> {
+}

sources/io/reactivex/internal/fuseable/HasUpstreamObservableSource.java

@@ -0,0 +1,5 @@
+package io.reactivex.internal.fuseable;
+
+/* loaded from: classes2.dex */
+public interface HasUpstreamObservableSource<T> {
+}

sources/io/reactivex/internal/fuseable/HasUpstreamPublisher.java

@@ -0,0 +1,5 @@
+package io.reactivex.internal.fuseable;
+
+/* loaded from: classes2.dex */
+public interface HasUpstreamPublisher<T> {
+}

sources/io/reactivex/internal/fuseable/QueueDisposable.java

@@ -0,0 +1,7 @@
+package io.reactivex.internal.fuseable;
+
+import io.reactivex.disposables.Disposable;
+
+/* loaded from: classes2.dex */
+public interface QueueDisposable<T> extends QueueFuseable<T>, Disposable {
+}

sources/io/reactivex/internal/fuseable/QueueFuseable.java

@@ -0,0 +1,6 @@
+package io.reactivex.internal.fuseable;
+
+/* loaded from: classes2.dex */
+public interface QueueFuseable<T> extends SimpleQueue<T> {
+    int requestFusion(int i);
+}

sources/io/reactivex/internal/fuseable/QueueSubscription.java

@@ -0,0 +1,7 @@
+package io.reactivex.internal.fuseable;
+
+import org.reactivestreams.Subscription;
+
+/* loaded from: classes2.dex */
+public interface QueueSubscription<T> extends QueueFuseable<T>, Subscription {
+}

sources/io/reactivex/internal/fuseable/ScalarCallable.java

@@ -0,0 +1,9 @@
+package io.reactivex.internal.fuseable;
+
+import java.util.concurrent.Callable;
+
+/* loaded from: classes2.dex */
+public interface ScalarCallable<T> extends Callable<T> {
+    @Override // java.util.concurrent.Callable
+    T call();
+}

sources/io/reactivex/internal/fuseable/SimplePlainQueue.java

@@ -0,0 +1,7 @@
+package io.reactivex.internal.fuseable;
+
+/* loaded from: classes2.dex */
+public interface SimplePlainQueue<T> extends SimpleQueue<T> {
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    T poll();
+}

sources/io/reactivex/internal/fuseable/SimpleQueue.java

@@ -0,0 +1,12 @@
+package io.reactivex.internal.fuseable;
+
+/* loaded from: classes2.dex */
+public interface SimpleQueue<T> {
+    void clear();
+
+    boolean isEmpty();
+
+    boolean offer(T t);
+
+    T poll() throws Exception;
+}

sources/io/reactivex/internal/observers/BasicFuseableObserver.java

@@ -0,0 +1,99 @@
+package io.reactivex.internal.observers;
+
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.fuseable.QueueDisposable;
+import io.reactivex.plugins.RxJavaPlugins;
+
+/* loaded from: classes2.dex */
+public abstract class BasicFuseableObserver<T, R> implements Observer<T>, QueueDisposable<R> {
+    protected final Observer<? super R> a;
+    protected Disposable b;
+    protected QueueDisposable<T> c;
+    protected boolean d;
+    protected int e;
+
+    public BasicFuseableObserver(Observer<? super R> observer) {
+        this.a = observer;
+    }
+
+    protected void a() {
+    }
+
+    protected final void a(Throwable th) {
+        Exceptions.b(th);
+        this.b.dispose();
+        onError(th);
+    }
+
+    protected boolean b() {
+        return true;
+    }
+
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public void clear() {
+        this.c.clear();
+    }
+
+    @Override // io.reactivex.disposables.Disposable
+    public void dispose() {
+        this.b.dispose();
+    }
+
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public boolean isEmpty() {
+        return this.c.isEmpty();
+    }
+
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public final boolean offer(R r) {
+        throw new UnsupportedOperationException("Should not be called!");
+    }
+
+    @Override // io.reactivex.Observer
+    public void onComplete() {
+        if (this.d) {
+            return;
+        }
+        this.d = 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 final void onSubscribe(Disposable disposable) {
+        if (DisposableHelper.validate(this.b, disposable)) {
+            this.b = disposable;
+            if (disposable instanceof QueueDisposable) {
+                this.c = (QueueDisposable) disposable;
+            }
+            if (b()) {
+                this.a.onSubscribe(this);
+                a();
+            }
+        }
+    }
+
+    protected final int a(int i) {
+        QueueDisposable<T> queueDisposable = this.c;
+        if (queueDisposable == null || (i & 4) != 0) {
+            return 0;
+        }
+        int requestFusion = queueDisposable.requestFusion(i);
+        if (requestFusion != 0) {
+            this.e = requestFusion;
+        }
+        return requestFusion;
+    }
+}

sources/io/reactivex/internal/observers/BasicIntQueueDisposable.java

@@ -0,0 +1,18 @@
+package io.reactivex.internal.observers;
+
+import io.reactivex.internal.fuseable.QueueDisposable;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/* loaded from: classes2.dex */
+public abstract class BasicIntQueueDisposable<T> extends AtomicInteger implements QueueDisposable<T> {
+    private static final long serialVersionUID = -1001730202384742097L;
+
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public final boolean offer(T t) {
+        throw new UnsupportedOperationException("Should not be called");
+    }
+
+    public final boolean offer(T t, T t2) {
+        throw new UnsupportedOperationException("Should not be called");
+    }
+}

sources/io/reactivex/internal/observers/BasicQueueDisposable.java

@@ -0,0 +1,11 @@
+package io.reactivex.internal.observers;
+
+import io.reactivex.internal.fuseable.QueueDisposable;
+
+/* loaded from: classes2.dex */
+public abstract class BasicQueueDisposable<T> implements QueueDisposable<T> {
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public final boolean offer(T t) {
+        throw new UnsupportedOperationException("Should not be called");
+    }
+}

sources/io/reactivex/internal/observers/BiConsumerSingleObserver.java

@@ -0,0 +1,56 @@
+package io.reactivex.internal.observers;
+
+import io.reactivex.SingleObserver;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.CompositeException;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.BiConsumer;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class BiConsumerSingleObserver<T> extends AtomicReference<Disposable> implements SingleObserver<T>, Disposable {
+    private static final long serialVersionUID = 4943102778943297569L;
+    final BiConsumer<? super T, ? super Throwable> onCallback;
+
+    public BiConsumerSingleObserver(BiConsumer<? super T, ? super Throwable> biConsumer) {
+        this.onCallback = biConsumer;
+    }
+
+    @Override // io.reactivex.disposables.Disposable
+    public void dispose() {
+        DisposableHelper.dispose(this);
+    }
+
+    public boolean isDisposed() {
+        return get() == DisposableHelper.DISPOSED;
+    }
+
+    @Override // io.reactivex.SingleObserver
+    public void onError(Throwable th) {
+        try {
+            lazySet(DisposableHelper.DISPOSED);
+            this.onCallback.a(null, th);
+        } catch (Throwable th2) {
+            Exceptions.b(th2);
+            RxJavaPlugins.b(new CompositeException(th, th2));
+        }
+    }
+
+    @Override // io.reactivex.SingleObserver
+    public void onSubscribe(Disposable disposable) {
+        DisposableHelper.setOnce(this, disposable);
+    }
+
+    @Override // io.reactivex.SingleObserver
+    public void onSuccess(T t) {
+        try {
+            lazySet(DisposableHelper.DISPOSED);
+            this.onCallback.a(t, null);
+        } catch (Throwable th) {
+            Exceptions.b(th);
+            RxJavaPlugins.b(th);
+        }
+    }
+}

sources/io/reactivex/internal/observers/BlockingBaseObserver.java

@@ -0,0 +1,58 @@
+package io.reactivex.internal.observers;
+
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.util.BlockingHelper;
+import io.reactivex.internal.util.ExceptionHelper;
+import java.util.concurrent.CountDownLatch;
+
+/* loaded from: classes2.dex */
+public abstract class BlockingBaseObserver<T> extends CountDownLatch implements Observer<T>, Disposable {
+    T a;
+    Throwable b;
+    Disposable c;
+    volatile boolean d;
+
+    public BlockingBaseObserver() {
+        super(1);
+    }
+
+    public final T a() {
+        if (getCount() != 0) {
+            try {
+                BlockingHelper.a();
+                await();
+            } catch (InterruptedException e) {
+                dispose();
+                throw ExceptionHelper.a(e);
+            }
+        }
+        Throwable th = this.b;
+        if (th == null) {
+            return this.a;
+        }
+        throw ExceptionHelper.a(th);
+    }
+
+    @Override // io.reactivex.disposables.Disposable
+    public final void dispose() {
+        this.d = true;
+        Disposable disposable = this.c;
+        if (disposable != null) {
+            disposable.dispose();
+        }
+    }
+
+    @Override // io.reactivex.Observer
+    public final void onComplete() {
+        countDown();
+    }
+
+    @Override // io.reactivex.Observer
+    public final void onSubscribe(Disposable disposable) {
+        this.c = disposable;
+        if (this.d) {
+            disposable.dispose();
+        }
+    }
+}

sources/io/reactivex/internal/observers/BlockingFirstObserver.java

@@ -0,0 +1,21 @@
+package io.reactivex.internal.observers;
+
+/* loaded from: classes2.dex */
+public final class BlockingFirstObserver<T> extends BlockingBaseObserver<T> {
+    @Override // io.reactivex.Observer
+    public void onError(Throwable th) {
+        if (this.a == null) {
+            this.b = th;
+        }
+        countDown();
+    }
+
+    @Override // io.reactivex.Observer
+    public void onNext(T t) {
+        if (this.a == null) {
+            this.a = t;
+            this.c.dispose();
+            countDown();
+        }
+    }
+}

sources/io/reactivex/internal/observers/BlockingLastObserver.java

@@ -0,0 +1,16 @@
+package io.reactivex.internal.observers;
+
+/* loaded from: classes2.dex */
+public final class BlockingLastObserver<T> extends BlockingBaseObserver<T> {
+    @Override // io.reactivex.Observer
+    public void onError(Throwable th) {
+        this.a = null;
+        this.b = th;
+        countDown();
+    }
+
+    @Override // io.reactivex.Observer
+    public void onNext(T t) {
+        this.a = t;
+    }
+}

sources/io/reactivex/internal/observers/BlockingMultiObserver.java

@@ -0,0 +1,71 @@
+package io.reactivex.internal.observers;
+
+import io.reactivex.CompletableObserver;
+import io.reactivex.MaybeObserver;
+import io.reactivex.SingleObserver;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.util.BlockingHelper;
+import io.reactivex.internal.util.ExceptionHelper;
+import java.util.concurrent.CountDownLatch;
+
+/* loaded from: classes2.dex */
+public final class BlockingMultiObserver<T> extends CountDownLatch implements SingleObserver<T>, CompletableObserver, MaybeObserver<T> {
+    T a;
+    Throwable b;
+    Disposable c;
+    volatile boolean d;
+
+    public BlockingMultiObserver() {
+        super(1);
+    }
+
+    public T a() {
+        if (getCount() != 0) {
+            try {
+                BlockingHelper.a();
+                await();
+            } catch (InterruptedException e) {
+                b();
+                throw ExceptionHelper.a(e);
+            }
+        }
+        Throwable th = this.b;
+        if (th == null) {
+            return this.a;
+        }
+        throw ExceptionHelper.a(th);
+    }
+
+    void b() {
+        this.d = true;
+        Disposable disposable = this.c;
+        if (disposable != null) {
+            disposable.dispose();
+        }
+    }
+
+    @Override // io.reactivex.CompletableObserver, io.reactivex.MaybeObserver
+    public void onComplete() {
+        countDown();
+    }
+
+    @Override // io.reactivex.SingleObserver
+    public void onError(Throwable th) {
+        this.b = th;
+        countDown();
+    }
+
+    @Override // io.reactivex.SingleObserver
+    public void onSubscribe(Disposable disposable) {
+        this.c = disposable;
+        if (this.d) {
+            disposable.dispose();
+        }
+    }
+
+    @Override // io.reactivex.SingleObserver
+    public void onSuccess(T t) {
+        this.a = t;
+        countDown();
+    }
+}

sources/io/reactivex/internal/observers/BlockingObserver.java

@@ -0,0 +1,50 @@
+package io.reactivex.internal.observers;
+
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.util.NotificationLite;
+import java.util.Queue;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class BlockingObserver<T> extends AtomicReference<Disposable> implements Observer<T>, Disposable {
+    public static final Object TERMINATED = new Object();
+    private static final long serialVersionUID = -4875965440900746268L;
+    final Queue<Object> queue;
+
+    public BlockingObserver(Queue<Object> queue) {
+        this.queue = queue;
+    }
+
+    @Override // io.reactivex.disposables.Disposable
+    public void dispose() {
+        if (DisposableHelper.dispose(this)) {
+            this.queue.offer(TERMINATED);
+        }
+    }
+
+    public boolean isDisposed() {
+        return get() == DisposableHelper.DISPOSED;
+    }
+
+    @Override // io.reactivex.Observer
+    public void onComplete() {
+        this.queue.offer(NotificationLite.complete());
+    }
+
+    @Override // io.reactivex.Observer
+    public void onError(Throwable th) {
+        this.queue.offer(NotificationLite.error(th));
+    }
+
+    @Override // io.reactivex.Observer
+    public void onNext(T t) {
+        this.queue.offer(NotificationLite.next(t));
+    }
+
+    @Override // io.reactivex.Observer
+    public void onSubscribe(Disposable disposable) {
+        DisposableHelper.setOnce(this, disposable);
+    }
+}

sources/io/reactivex/internal/observers/CallbackCompletableObserver.java

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

sources/io/reactivex/internal/observers/ConsumerSingleObserver.java

@@ -0,0 +1,64 @@
+package io.reactivex.internal.observers;
+
+import io.reactivex.SingleObserver;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.CompositeException;
+import io.reactivex.exceptions.Exceptions;
+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 ConsumerSingleObserver<T> extends AtomicReference<Disposable> implements SingleObserver<T>, Disposable, LambdaConsumerIntrospection {
+    private static final long serialVersionUID = -7012088219455310787L;
+    final Consumer<? super Throwable> onError;
+    final Consumer<? super T> onSuccess;
+
+    public ConsumerSingleObserver(Consumer<? super T> consumer, Consumer<? super Throwable> consumer2) {
+        this.onSuccess = consumer;
+        this.onError = consumer2;
+    }
+
+    @Override // io.reactivex.disposables.Disposable
+    public void dispose() {
+        DisposableHelper.dispose(this);
+    }
+
+    public boolean hasCustomOnError() {
+        return this.onError != Functions.e;
+    }
+
+    public boolean isDisposed() {
+        return get() == DisposableHelper.DISPOSED;
+    }
+
+    @Override // io.reactivex.SingleObserver
+    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.SingleObserver
+    public void onSubscribe(Disposable disposable) {
+        DisposableHelper.setOnce(this, disposable);
+    }
+
+    @Override // io.reactivex.SingleObserver
+    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/observers/DeferredScalarDisposable.java

@@ -0,0 +1,101 @@
+package io.reactivex.internal.observers;
+
+import io.reactivex.Observer;
+import io.reactivex.plugins.RxJavaPlugins;
+
+/* loaded from: classes2.dex */
+public class DeferredScalarDisposable<T> extends BasicIntQueueDisposable<T> {
+    static final int DISPOSED = 4;
+    static final int FUSED_CONSUMED = 32;
+    static final int FUSED_EMPTY = 8;
+    static final int FUSED_READY = 16;
+    static final int TERMINATED = 2;
+    private static final long serialVersionUID = -5502432239815349361L;
+    protected final Observer<? super T> downstream;
+    protected T value;
+
+    public DeferredScalarDisposable(Observer<? super T> observer) {
+        this.downstream = observer;
+    }
+
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public final void clear() {
+        lazySet(32);
+        this.value = null;
+    }
+
+    public final void complete(T t) {
+        int i = get();
+        if ((i & 54) != 0) {
+            return;
+        }
+        Observer<? super T> observer = this.downstream;
+        if (i == 8) {
+            this.value = t;
+            lazySet(16);
+            observer.onNext(null);
+        } else {
+            lazySet(2);
+            observer.onNext(t);
+        }
+        if (get() != 4) {
+            observer.onComplete();
+        }
+    }
+
+    @Override // io.reactivex.disposables.Disposable
+    public void dispose() {
+        set(4);
+        this.value = null;
+    }
+
+    public final void error(Throwable th) {
+        if ((get() & 54) != 0) {
+            RxJavaPlugins.b(th);
+        } else {
+            lazySet(2);
+            this.downstream.onError(th);
+        }
+    }
+
+    public final boolean isDisposed() {
+        return get() == 4;
+    }
+
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public final boolean isEmpty() {
+        return get() != 16;
+    }
+
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public final T poll() throws Exception {
+        if (get() != 16) {
+            return null;
+        }
+        T t = this.value;
+        this.value = null;
+        lazySet(32);
+        return t;
+    }
+
+    @Override // io.reactivex.internal.fuseable.QueueFuseable
+    public final int requestFusion(int i) {
+        if ((i & 2) == 0) {
+            return 0;
+        }
+        lazySet(8);
+        return 2;
+    }
+
+    public final boolean tryDispose() {
+        return getAndSet(4) != 4;
+    }
+
+    public final void complete() {
+        if ((get() & 54) != 0) {
+            return;
+        }
+        lazySet(2);
+        this.downstream.onComplete();
+    }
+}

sources/io/reactivex/internal/observers/DeferredScalarObserver.java

@@ -0,0 +1,46 @@
+package io.reactivex.internal.observers;
+
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+
+/* loaded from: classes2.dex */
+public abstract class DeferredScalarObserver<T, R> extends DeferredScalarDisposable<R> implements Observer<T> {
+    private static final long serialVersionUID = -266195175408988651L;
+    protected Disposable upstream;
+
+    public DeferredScalarObserver(Observer<? super R> observer) {
+        super(observer);
+    }
+
+    @Override // io.reactivex.internal.observers.DeferredScalarDisposable, io.reactivex.disposables.Disposable
+    public void dispose() {
+        super.dispose();
+        this.upstream.dispose();
+    }
+
+    @Override // io.reactivex.Observer
+    public void onComplete() {
+        T t = this.value;
+        if (t == null) {
+            complete();
+        } else {
+            this.value = null;
+            complete(t);
+        }
+    }
+
+    @Override // io.reactivex.Observer
+    public void onError(Throwable th) {
+        this.value = null;
+        error(th);
+    }
+
+    @Override // io.reactivex.Observer
+    public void onSubscribe(Disposable disposable) {
+        if (DisposableHelper.validate(this.upstream, disposable)) {
+            this.upstream = disposable;
+            this.downstream.onSubscribe(this);
+        }
+    }
+}

sources/io/reactivex/internal/observers/DisposableLambdaObserver.java

@@ -0,0 +1,72 @@
+package io.reactivex.internal.observers;
+
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+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.disposables.EmptyDisposable;
+import io.reactivex.plugins.RxJavaPlugins;
+
+/* loaded from: classes2.dex */
+public final class DisposableLambdaObserver<T> implements Observer<T>, Disposable {
+    final Observer<? super T> a;
+    final Consumer<? super Disposable> b;
+    final Action c;
+    Disposable d;
+
+    public DisposableLambdaObserver(Observer<? super T> observer, Consumer<? super Disposable> consumer, Action action) {
+        this.a = observer;
+        this.b = consumer;
+        this.c = action;
+    }
+
+    @Override // io.reactivex.disposables.Disposable
+    public void dispose() {
+        try {
+            this.c.run();
+        } catch (Throwable th) {
+            Exceptions.b(th);
+            RxJavaPlugins.b(th);
+        }
+        this.d.dispose();
+    }
+
+    @Override // io.reactivex.Observer
+    public void onComplete() {
+        if (this.d != DisposableHelper.DISPOSED) {
+            this.a.onComplete();
+        }
+    }
+
+    @Override // io.reactivex.Observer
+    public void onError(Throwable th) {
+        if (this.d != DisposableHelper.DISPOSED) {
+            this.a.onError(th);
+        } else {
+            RxJavaPlugins.b(th);
+        }
+    }
+
+    @Override // io.reactivex.Observer
+    public void onNext(T t) {
+        this.a.onNext(t);
+    }
+
+    @Override // io.reactivex.Observer
+    public void onSubscribe(Disposable disposable) {
+        try {
+            this.b.accept(disposable);
+            if (DisposableHelper.validate(this.d, disposable)) {
+                this.d = disposable;
+                this.a.onSubscribe(this);
+            }
+        } catch (Throwable th) {
+            Exceptions.b(th);
+            disposable.dispose();
+            this.d = DisposableHelper.DISPOSED;
+            EmptyDisposable.error(th, this.a);
+        }
+    }
+}

sources/io/reactivex/internal/observers/EmptyCompletableObserver.java

@@ -0,0 +1,43 @@
+package io.reactivex.internal.observers;
+
+import io.reactivex.CompletableObserver;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.OnErrorNotImplementedException;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.observers.LambdaConsumerIntrospection;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class EmptyCompletableObserver extends AtomicReference<Disposable> implements CompletableObserver, Disposable, LambdaConsumerIntrospection {
+    private static final long serialVersionUID = -7545121636549663526L;
+
+    @Override // io.reactivex.disposables.Disposable
+    public void dispose() {
+        DisposableHelper.dispose(this);
+    }
+
+    public boolean hasCustomOnError() {
+        return false;
+    }
+
+    public boolean isDisposed() {
+        return get() == DisposableHelper.DISPOSED;
+    }
+
+    @Override // io.reactivex.CompletableObserver, io.reactivex.MaybeObserver
+    public void onComplete() {
+        lazySet(DisposableHelper.DISPOSED);
+    }
+
+    @Override // io.reactivex.CompletableObserver
+    public void onError(Throwable th) {
+        lazySet(DisposableHelper.DISPOSED);
+        RxJavaPlugins.b(new OnErrorNotImplementedException(th));
+    }
+
+    @Override // io.reactivex.CompletableObserver
+    public void onSubscribe(Disposable disposable) {
+        DisposableHelper.setOnce(this, disposable);
+    }
+}

sources/io/reactivex/internal/observers/ForEachWhileObserver.java

@@ -0,0 +1,88 @@
+package io.reactivex.internal.observers;
+
+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.functions.Predicate;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class ForEachWhileObserver<T> extends AtomicReference<Disposable> implements Observer<T>, Disposable {
+    private static final long serialVersionUID = -4403180040475402120L;
+    boolean done;
+    final Action onComplete;
+    final Consumer<? super Throwable> onError;
+    final Predicate<? super T> onNext;
+
+    public ForEachWhileObserver(Predicate<? super T> predicate, Consumer<? super Throwable> consumer, Action action) {
+        this.onNext = predicate;
+        this.onError = consumer;
+        this.onComplete = action;
+    }
+
+    @Override // io.reactivex.disposables.Disposable
+    public void dispose() {
+        DisposableHelper.dispose(this);
+    }
+
+    public boolean isDisposed() {
+        return DisposableHelper.isDisposed(get());
+    }
+
+    @Override // io.reactivex.Observer
+    public void onComplete() {
+        if (this.done) {
+            return;
+        }
+        this.done = true;
+        try {
+            this.onComplete.run();
+        } catch (Throwable th) {
+            Exceptions.b(th);
+            RxJavaPlugins.b(th);
+        }
+    }
+
+    @Override // io.reactivex.Observer
+    public void onError(Throwable th) {
+        if (this.done) {
+            RxJavaPlugins.b(th);
+            return;
+        }
+        this.done = true;
+        try {
+            this.onError.accept(th);
+        } catch (Throwable th2) {
+            Exceptions.b(th2);
+            RxJavaPlugins.b(new CompositeException(th, th2));
+        }
+    }
+
+    @Override // io.reactivex.Observer
+    public void onNext(T t) {
+        if (this.done) {
+            return;
+        }
+        try {
+            if (this.onNext.a(t)) {
+                return;
+            }
+            dispose();
+            onComplete();
+        } catch (Throwable th) {
+            Exceptions.b(th);
+            dispose();
+            onError(th);
+        }
+    }
+
+    @Override // io.reactivex.Observer
+    public void onSubscribe(Disposable disposable) {
+        DisposableHelper.setOnce(this, disposable);
+    }
+}

sources/io/reactivex/internal/observers/FutureObserver.java

@@ -0,0 +1,141 @@
+package io.reactivex.internal.observers;
+
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.util.BlockingHelper;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.NoSuchElementException;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class FutureObserver<T> extends CountDownLatch implements Observer<T>, Future<T>, Disposable {
+    T a;
+    Throwable b;
+    final AtomicReference<Disposable> c;
+
+    public FutureObserver() {
+        super(1);
+        this.c = new AtomicReference<>();
+    }
+
+    @Override // java.util.concurrent.Future
+    public boolean cancel(boolean z) {
+        Disposable disposable;
+        DisposableHelper disposableHelper;
+        do {
+            disposable = this.c.get();
+            if (disposable == this || disposable == (disposableHelper = DisposableHelper.DISPOSED)) {
+                return false;
+            }
+        } while (!this.c.compareAndSet(disposable, disposableHelper));
+        if (disposable != null) {
+            disposable.dispose();
+        }
+        countDown();
+        return true;
+    }
+
+    @Override // io.reactivex.disposables.Disposable
+    public void dispose() {
+    }
+
+    @Override // java.util.concurrent.Future
+    public T get() throws InterruptedException, ExecutionException {
+        if (getCount() != 0) {
+            BlockingHelper.a();
+            await();
+        }
+        if (isCancelled()) {
+            throw new CancellationException();
+        }
+        Throwable th = this.b;
+        if (th == null) {
+            return this.a;
+        }
+        throw new ExecutionException(th);
+    }
+
+    @Override // java.util.concurrent.Future
+    public boolean isCancelled() {
+        return DisposableHelper.isDisposed(this.c.get());
+    }
+
+    @Override // java.util.concurrent.Future
+    public boolean isDone() {
+        return getCount() == 0;
+    }
+
+    @Override // io.reactivex.Observer
+    public void onComplete() {
+        Disposable disposable;
+        if (this.a == null) {
+            onError(new NoSuchElementException("The source is empty"));
+            return;
+        }
+        do {
+            disposable = this.c.get();
+            if (disposable == this || disposable == DisposableHelper.DISPOSED) {
+                return;
+            }
+        } while (!this.c.compareAndSet(disposable, this));
+        countDown();
+    }
+
+    @Override // io.reactivex.Observer
+    public void onError(Throwable th) {
+        Disposable disposable;
+        if (this.b != null) {
+            RxJavaPlugins.b(th);
+            return;
+        }
+        this.b = th;
+        do {
+            disposable = this.c.get();
+            if (disposable == this || disposable == DisposableHelper.DISPOSED) {
+                RxJavaPlugins.b(th);
+                return;
+            }
+        } while (!this.c.compareAndSet(disposable, this));
+        countDown();
+    }
+
+    @Override // io.reactivex.Observer
+    public void onNext(T t) {
+        if (this.a == null) {
+            this.a = t;
+        } else {
+            this.c.get().dispose();
+            onError(new IndexOutOfBoundsException("More than one element received"));
+        }
+    }
+
+    @Override // io.reactivex.Observer
+    public void onSubscribe(Disposable disposable) {
+        DisposableHelper.setOnce(this.c, disposable);
+    }
+
+    @Override // java.util.concurrent.Future
+    public T get(long j, TimeUnit timeUnit) throws InterruptedException, ExecutionException, TimeoutException {
+        if (getCount() != 0) {
+            BlockingHelper.a();
+            if (!await(j, timeUnit)) {
+                throw new TimeoutException();
+            }
+        }
+        if (!isCancelled()) {
+            Throwable th = this.b;
+            if (th == null) {
+                return this.a;
+            }
+            throw new ExecutionException(th);
+        }
+        throw new CancellationException();
+    }
+}

sources/io/reactivex/internal/observers/InnerQueuedObserver.java

@@ -0,0 +1,91 @@
+package io.reactivex.internal.observers;
+
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.fuseable.QueueDisposable;
+import io.reactivex.internal.fuseable.SimpleQueue;
+import io.reactivex.internal.util.QueueDrainHelper;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class InnerQueuedObserver<T> extends AtomicReference<Disposable> implements Observer<T>, Disposable {
+    private static final long serialVersionUID = -5417183359794346637L;
+    volatile boolean done;
+    int fusionMode;
+    final InnerQueuedObserverSupport<T> parent;
+    final int prefetch;
+    SimpleQueue<T> queue;
+
+    public InnerQueuedObserver(InnerQueuedObserverSupport<T> innerQueuedObserverSupport, int i) {
+        this.parent = innerQueuedObserverSupport;
+        this.prefetch = i;
+    }
+
+    @Override // io.reactivex.disposables.Disposable
+    public void dispose() {
+        DisposableHelper.dispose(this);
+    }
+
+    public int fusionMode() {
+        return this.fusionMode;
+    }
+
+    public boolean isDisposed() {
+        return DisposableHelper.isDisposed(get());
+    }
+
+    public boolean isDone() {
+        return this.done;
+    }
+
+    @Override // io.reactivex.Observer
+    public void onComplete() {
+        this.parent.a(this);
+    }
+
+    @Override // io.reactivex.Observer
+    public void onError(Throwable th) {
+        this.parent.a((InnerQueuedObserver) this, th);
+    }
+
+    @Override // io.reactivex.Observer
+    public void onNext(T t) {
+        if (this.fusionMode == 0) {
+            this.parent.a((InnerQueuedObserver<InnerQueuedObserver<T>>) this, (InnerQueuedObserver<T>) t);
+        } else {
+            this.parent.a();
+        }
+    }
+
+    @Override // io.reactivex.Observer
+    public void onSubscribe(Disposable disposable) {
+        if (DisposableHelper.setOnce(this, disposable)) {
+            if (disposable instanceof QueueDisposable) {
+                QueueDisposable queueDisposable = (QueueDisposable) disposable;
+                int requestFusion = queueDisposable.requestFusion(3);
+                if (requestFusion == 1) {
+                    this.fusionMode = requestFusion;
+                    this.queue = queueDisposable;
+                    this.done = true;
+                    this.parent.a(this);
+                    return;
+                }
+                if (requestFusion == 2) {
+                    this.fusionMode = requestFusion;
+                    this.queue = queueDisposable;
+                    return;
+                }
+            }
+            this.queue = QueueDrainHelper.a(-this.prefetch);
+        }
+    }
+
+    public SimpleQueue<T> queue() {
+        return this.queue;
+    }
+
+    public void setDone() {
+        this.done = true;
+    }
+}

sources/io/reactivex/internal/observers/InnerQueuedObserverSupport.java

@@ -0,0 +1,12 @@
+package io.reactivex.internal.observers;
+
+/* loaded from: classes2.dex */
+public interface InnerQueuedObserverSupport<T> {
+    void a();
+
+    void a(InnerQueuedObserver<T> innerQueuedObserver);
+
+    void a(InnerQueuedObserver<T> innerQueuedObserver, T t);
+
+    void a(InnerQueuedObserver<T> innerQueuedObserver, Throwable th);
+}

sources/io/reactivex/internal/observers/LambdaObserver.java

@@ -0,0 +1,98 @@
+package io.reactivex.internal.observers;
+
+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.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 LambdaObserver<T> extends AtomicReference<Disposable> implements Observer<T>, Disposable, LambdaConsumerIntrospection {
+    private static final long serialVersionUID = -7251123623727029452L;
+    final Action onComplete;
+    final Consumer<? super Throwable> onError;
+    final Consumer<? super T> onNext;
+    final Consumer<? super Disposable> onSubscribe;
+
+    public LambdaObserver(Consumer<? super T> consumer, Consumer<? super Throwable> consumer2, Action action, Consumer<? super Disposable> consumer3) {
+        this.onNext = consumer;
+        this.onError = consumer2;
+        this.onComplete = action;
+        this.onSubscribe = consumer3;
+    }
+
+    @Override // io.reactivex.disposables.Disposable
+    public void dispose() {
+        DisposableHelper.dispose(this);
+    }
+
+    public boolean hasCustomOnError() {
+        return this.onError != Functions.e;
+    }
+
+    public boolean isDisposed() {
+        return get() == DisposableHelper.DISPOSED;
+    }
+
+    @Override // io.reactivex.Observer
+    public void onComplete() {
+        if (isDisposed()) {
+            return;
+        }
+        lazySet(DisposableHelper.DISPOSED);
+        try {
+            this.onComplete.run();
+        } catch (Throwable th) {
+            Exceptions.b(th);
+            RxJavaPlugins.b(th);
+        }
+    }
+
+    @Override // io.reactivex.Observer
+    public void onError(Throwable th) {
+        if (isDisposed()) {
+            RxJavaPlugins.b(th);
+            return;
+        }
+        lazySet(DisposableHelper.DISPOSED);
+        try {
+            this.onError.accept(th);
+        } catch (Throwable th2) {
+            Exceptions.b(th2);
+            RxJavaPlugins.b(new CompositeException(th, th2));
+        }
+    }
+
+    @Override // io.reactivex.Observer
+    public void onNext(T t) {
+        if (isDisposed()) {
+            return;
+        }
+        try {
+            this.onNext.accept(t);
+        } catch (Throwable th) {
+            Exceptions.b(th);
+            get().dispose();
+            onError(th);
+        }
+    }
+
+    @Override // io.reactivex.Observer
+    public void onSubscribe(Disposable disposable) {
+        if (DisposableHelper.setOnce(this, disposable)) {
+            try {
+                this.onSubscribe.accept(this);
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                disposable.dispose();
+                onError(th);
+            }
+        }
+    }
+}

sources/io/reactivex/internal/observers/QueueDrainObserver.java

@@ -0,0 +1,89 @@
+package io.reactivex.internal.observers;
+
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.fuseable.SimplePlainQueue;
+import io.reactivex.internal.util.ObservableQueueDrain;
+import io.reactivex.internal.util.QueueDrainHelper;
+
+/* loaded from: classes2.dex */
+public abstract class QueueDrainObserver<T, U, V> extends QueueDrainSubscriberPad2 implements Observer<T>, ObservableQueueDrain<U, V> {
+    protected final Observer<? super V> b;
+    protected final SimplePlainQueue<U> c;
+    protected volatile boolean d;
+    protected volatile boolean e;
+    protected Throwable f;
+
+    public QueueDrainObserver(Observer<? super V> observer, SimplePlainQueue<U> simplePlainQueue) {
+        this.b = observer;
+        this.c = simplePlainQueue;
+    }
+
+    @Override // io.reactivex.internal.util.ObservableQueueDrain
+    public void a(Observer<? super V> observer, U u) {
+    }
+
+    @Override // io.reactivex.internal.util.ObservableQueueDrain
+    public final boolean a() {
+        return this.e;
+    }
+
+    @Override // io.reactivex.internal.util.ObservableQueueDrain
+    public final boolean b() {
+        return this.d;
+    }
+
+    @Override // io.reactivex.internal.util.ObservableQueueDrain
+    public final Throwable c() {
+        return this.f;
+    }
+
+    public final boolean d() {
+        return this.a.getAndIncrement() == 0;
+    }
+
+    public final boolean e() {
+        return this.a.get() == 0 && this.a.compareAndSet(0, 1);
+    }
+
+    protected final void a(U u, boolean z, Disposable disposable) {
+        Observer<? super V> observer = this.b;
+        SimplePlainQueue<U> simplePlainQueue = this.c;
+        if (this.a.get() == 0 && this.a.compareAndSet(0, 1)) {
+            a(observer, u);
+            if (a(-1) == 0) {
+                return;
+            }
+        } else {
+            simplePlainQueue.offer(u);
+            if (!d()) {
+                return;
+            }
+        }
+        QueueDrainHelper.a(simplePlainQueue, observer, z, disposable, this);
+    }
+
+    protected final void b(U u, boolean z, Disposable disposable) {
+        Observer<? super V> observer = this.b;
+        SimplePlainQueue<U> simplePlainQueue = this.c;
+        if (this.a.get() != 0 || !this.a.compareAndSet(0, 1)) {
+            simplePlainQueue.offer(u);
+            if (!d()) {
+                return;
+            }
+        } else if (simplePlainQueue.isEmpty()) {
+            a(observer, u);
+            if (a(-1) == 0) {
+                return;
+            }
+        } else {
+            simplePlainQueue.offer(u);
+        }
+        QueueDrainHelper.a(simplePlainQueue, observer, z, disposable, this);
+    }
+
+    @Override // io.reactivex.internal.util.ObservableQueueDrain
+    public final int a(int i) {
+        return this.a.addAndGet(i);
+    }
+}

sources/io/reactivex/internal/observers/QueueDrainSubscriberPad0.java

@@ -0,0 +1,8 @@
+package io.reactivex.internal.observers;
+
+/* compiled from: QueueDrainObserver.java */
+/* loaded from: classes2.dex */
+class QueueDrainSubscriberPad0 {
+    QueueDrainSubscriberPad0() {
+    }
+}

sources/io/reactivex/internal/observers/QueueDrainSubscriberPad2.java

@@ -0,0 +1,8 @@
+package io.reactivex.internal.observers;
+
+/* compiled from: QueueDrainObserver.java */
+/* loaded from: classes2.dex */
+class QueueDrainSubscriberPad2 extends QueueDrainSubscriberWip {
+    QueueDrainSubscriberPad2() {
+    }
+}

sources/io/reactivex/internal/observers/QueueDrainSubscriberWip.java

@@ -0,0 +1,12 @@
+package io.reactivex.internal.observers;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+/* compiled from: QueueDrainObserver.java */
+/* loaded from: classes2.dex */
+class QueueDrainSubscriberWip extends QueueDrainSubscriberPad0 {
+    final AtomicInteger a = new AtomicInteger();
+
+    QueueDrainSubscriberWip() {
+    }
+}

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));
+    }
+}