package io.reactivex.internal.operators.observable;

import io.reactivex.internal.disposables.DisposableHelper;
import java.util.concurrent.atomic.AtomicReference;
import 㴹.K.AbstractC2500;
import 㴹.K.AbstractC2508;
import 㴹.K.AbstractC2518;
import 㴹.K.AbstractC2520;
import 㴹.K.Ԕ.ඓ.ῲ.AbstractC2445;
import 㴹.K.㑃.AbstractC2514;

public final class ObservableSubscribeOn<T> extends AbstractC2445<T, T> {

    /* renamed from: ʬ  reason: contains not printable characters */
    public final AbstractC2508 f3435;

    public static final class SubscribeOnObserver<T> extends AtomicReference<AbstractC2514> implements AbstractC2520<T>, AbstractC2514 {
        public static final long serialVersionUID = 8094547886072529208L;
        public final AbstractC2520<? super T> actual;
        public final AtomicReference<AbstractC2514> s = new AtomicReference<>();

        public SubscribeOnObserver(AbstractC2520<? super T> r1) {
            this.actual = r1;
        }

        @Override // 㴹.K.㑃.AbstractC2514
        public void dispose() {
            DisposableHelper.dispose(this.s);
            DisposableHelper.dispose(this);
        }

        @Override // 㴹.K.㑃.AbstractC2514
        public boolean isDisposed() {
            return DisposableHelper.isDisposed((AbstractC2514) get());
        }

        @Override // 㴹.K.AbstractC2520
        public void onComplete() {
            this.actual.onComplete();
        }

        @Override // 㴹.K.AbstractC2520
        public void onError(Throwable th) {
            this.actual.onError(th);
        }

        @Override // 㴹.K.AbstractC2520
        public void onNext(T t) {
            this.actual.onNext(t);
        }

        @Override // 㴹.K.AbstractC2520
        public void onSubscribe(AbstractC2514 r2) {
            DisposableHelper.setOnce(this.s, r2);
        }

        public void setDisposable(AbstractC2514 r1) {
            DisposableHelper.setOnce(this, r1);
        }
    }

    /* renamed from: io.reactivex.internal.operators.observable.ObservableSubscribeOn$K  reason: contains not printable characters */
    public final class RunnableC0575 implements Runnable {

        /* renamed from: ῲ  reason: contains not printable characters */
        public final SubscribeOnObserver<T> f3437;

        public RunnableC0575(SubscribeOnObserver<T> subscribeOnObserver) {
            this.f3437 = subscribeOnObserver;
        }

        public void run() {
            ((AbstractC2500) ObservableSubscribeOn.this.f8388).m6545((AbstractC2520) this.f3437);
        }
    }

    public ObservableSubscribeOn(AbstractC2518<T> r1, AbstractC2508 r2) {
        super(r1);
        this.f3435 = r2;
    }

    @Override // 㴹.K.AbstractC2500
    /* renamed from: ῲ  reason: contains not printable characters */
    public void m1953(AbstractC2520<? super T> r3) {
        SubscribeOnObserver subscribeOnObserver = new SubscribeOnObserver(r3);
        r3.onSubscribe(subscribeOnObserver);
        subscribeOnObserver.setDisposable(this.f3435.m6551(new RunnableC0575(subscribeOnObserver)));
    }
}
