package defpackage;

import java.util.concurrent.CancellationException;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
import kotlinx.coroutines.CompletionHandlerException;
import kotlinx.coroutines.DispatchException;
import sun.misc.Unsafe;

/* JADX INFO: renamed from: ᵤᵩᵾ, reason: contains not printable characters */
/* JADX INFO: loaded from: classes3.dex */
public class C3453 extends AbstractC0795 implements InterfaceC0573, InterfaceC3912, InterfaceC2973 {

    /* JADX INFO: renamed from: ˌᵨʠᵫ, reason: contains not printable characters */
    public static final /* synthetic */ AtomicReferenceFieldUpdater f13315;

    /* JADX INFO: renamed from: ˑˊᵲ, reason: contains not printable characters */
    public static final /* synthetic */ long f13316;

    /* JADX INFO: renamed from: ᵸˆˁ, reason: contains not printable characters */
    public static final /* synthetic */ long f13318;
    private volatile /* synthetic */ int _decisionAndIndex$volatile;
    private volatile /* synthetic */ Object _parentHandle$volatile;
    private volatile /* synthetic */ Object _state$volatile;

    /* JADX INFO: renamed from: ᵨᵼⁱ, reason: contains not printable characters */
    public final InterfaceC2643 f13319;

    /* JADX INFO: renamed from: ᵯᵷʽ, reason: contains not printable characters */
    public final InterfaceC3822 f13320;

    /* JADX INFO: renamed from: ᵶˇᵱ, reason: contains not printable characters */
    public static final /* synthetic */ AtomicIntegerFieldUpdater f13317 = AtomicIntegerFieldUpdater.newUpdater(C3453.class, "_decisionAndIndex$volatile");

    /* JADX INFO: renamed from: ˈᵲᵢ, reason: contains not printable characters */
    public static final /* synthetic */ AtomicReferenceFieldUpdater f13314 = AtomicReferenceFieldUpdater.newUpdater(C3453.class, Object.class, "_state$volatile");

    static {
        Unsafe unsafe = AbstractC1929.f7689;
        f13316 = unsafe.objectFieldOffset(C3453.class.getDeclaredField("_state$volatile"));
        f13315 = AtomicReferenceFieldUpdater.newUpdater(C3453.class, Object.class, "_parentHandle$volatile");
        f13318 = unsafe.objectFieldOffset(C3453.class.getDeclaredField("_parentHandle$volatile"));
    }

    public C3453(int i, InterfaceC2643 interfaceC2643) {
        super(i);
        this.f13319 = interfaceC2643;
        this.f13320 = interfaceC2643.mo1376();
        this._decisionAndIndex$volatile = 536870911;
        this._state$volatile = C1778.f7136;
    }

    /* JADX INFO: renamed from: ˁˌᵩ, reason: contains not printable characters */
    public static Object m7866(InterfaceC2347 interfaceC2347, Object obj, int i, InterfaceC4400 interfaceC4400) {
        if (obj instanceof C5507) {
            return obj;
        }
        if (i != 1 && i != 2) {
            return obj;
        }
        if (interfaceC4400 != null || (interfaceC2347 instanceof InterfaceC5450)) {
            return new C5281(obj, interfaceC2347 instanceof InterfaceC5450 ? (InterfaceC5450) interfaceC2347 : null, interfaceC4400, (Throwable) null, 16);
        }
        return obj;
    }

    /* JADX INFO: renamed from: ˌᵨʠᵫ, reason: contains not printable characters */
    public static void m7867(Object obj, Object obj2) {
        throw new IllegalStateException(("It's prohibited to register multiple handlers, tried to register " + obj + ", already has " + obj2).toString());
    }

    public final String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(mo7888());
        sb.append('(');
        sb.append(ᵹˊᵫˋ.ˈᵲᵢ(this.f13319));
        sb.append("){");
        Object objM7879 = m7879();
        sb.append(objM7879 instanceof InterfaceC2347 ? "Active" : objM7879 instanceof C0190 ? "Cancelled" : "Completed");
        sb.append("}@");
        sb.append(ᵹˊᵫˋ.ᵶᵥᵝ(this));
        return sb.toString();
    }

    @Override // defpackage.AbstractC0795
    /* JADX INFO: renamed from: ʽˈˋ */
    public final void mo2885(CancellationException cancellationException) {
        CancellationException cancellationException2;
        C3453 c3453;
        while (true) {
            f13314.getClass();
            Unsafe unsafe = AbstractC1929.f7689;
            long j = f13316;
            Object objectVolatile = unsafe.getObjectVolatile(this, j);
            if (objectVolatile instanceof InterfaceC2347) {
                ᵕᵩʽᵲ.ᵪᵹᵥᵻ("Not completed");
                return;
            }
            if (objectVolatile instanceof C5507) {
                return;
            }
            if (objectVolatile instanceof C5281) {
                C5281 c5281 = (C5281) objectVolatile;
                if (c5281.f19938 != null) {
                    ᵕᵩʽᵲ.ᵪᵹᵥᵻ("Must be called at most once");
                    return;
                }
                C5281 c5281M10875 = C5281.m10875(c5281, null, cancellationException, 15);
                while (true) {
                    Unsafe unsafe2 = AbstractC1929.f7689;
                    C3453 c34532 = this;
                    if (unsafe2.compareAndSwapObject(c34532, f13316, objectVolatile, c5281M10875)) {
                        InterfaceC5450 interfaceC5450 = c5281.f19936;
                        if (interfaceC5450 != null) {
                            c34532.m7887(interfaceC5450, cancellationException);
                        }
                        InterfaceC4400 interfaceC4400 = c5281.f19937;
                        if (interfaceC4400 != null) {
                            c34532.m7880(interfaceC4400, cancellationException, c5281.f19939);
                            return;
                        }
                        return;
                    }
                    if (unsafe2.getObjectVolatile(c34532, j) != objectVolatile) {
                        cancellationException2 = cancellationException;
                        c3453 = c34532;
                        break;
                    }
                    this = c34532;
                }
            } else {
                C3453 c34533 = this;
                CancellationException cancellationException3 = cancellationException;
                C5281 c52812 = new C5281(objectVolatile, (InterfaceC5450) null, (InterfaceC4400) null, cancellationException3, 14);
                cancellationException2 = cancellationException3;
                while (true) {
                    C5281 c52813 = c52812;
                    Unsafe unsafe3 = AbstractC1929.f7689;
                    c3453 = c34533;
                    boolean zCompareAndSwapObject = unsafe3.compareAndSwapObject(c3453, f13316, objectVolatile, c52813);
                    c52812 = c52813;
                    if (zCompareAndSwapObject) {
                        return;
                    }
                    if (unsafe3.getObjectVolatile(c3453, j) != objectVolatile) {
                        break;
                    } else {
                        c34533 = c3453;
                    }
                }
            }
            cancellationException = cancellationException2;
            this = c3453;
        }
    }

    /* JADX INFO: renamed from: ʿٴˇ, reason: contains not printable characters */
    public final boolean m7868() {
        f13314.getClass();
        Unsafe unsafe = AbstractC1929.f7689;
        long j = f13316;
        Object objectVolatile = unsafe.getObjectVolatile(this, j);
        if ((objectVolatile instanceof C5281) && ((C5281) objectVolatile).f19940 != null) {
            m7873();
            return false;
        }
        f13317.set(this, 536870911);
        unsafe.putObjectVolatile(this, j, C1778.f7136);
        return true;
    }

    /* JADX INFO: renamed from: ˀᵭ, reason: contains not printable characters */
    public final C1735 m7869(Object obj, InterfaceC4400 interfaceC4400) {
        C3453 c3453;
        while (true) {
            f13314.getClass();
            Unsafe unsafe = AbstractC1929.f7689;
            long j = f13316;
            Object objectVolatile = unsafe.getObjectVolatile(this, j);
            if (!(objectVolatile instanceof InterfaceC2347)) {
                return null;
            }
            Object objM7866 = m7866((InterfaceC2347) objectVolatile, obj, this.f3575, interfaceC4400);
            while (true) {
                Unsafe unsafe2 = AbstractC1929.f7689;
                c3453 = this;
                if (unsafe2.compareAndSwapObject(c3453, f13316, objectVolatile, objM7866)) {
                    boolean zM7870 = c3453.m7870();
                    C1735 c1735 = AbstractC3204.f12183;
                    if (!zM7870) {
                        c3453.m7873();
                    }
                    return c1735;
                }
                if (unsafe2.getObjectVolatile(c3453, j) != objectVolatile) {
                    break;
                }
                this = c3453;
            }
            this = c3453;
        }
    }

    /* JADX INFO: renamed from: ˈᵲᵢ, reason: contains not printable characters */
    public final boolean m7870() {
        return this.f3575 == 2 && ((C4295) this.f13319).m9276();
    }

    /* JADX INFO: renamed from: ˉᵲ, reason: contains not printable characters */
    public final void m7871(int i) throws DispatchException {
        AtomicIntegerFieldUpdater atomicIntegerFieldUpdater;
        int i2;
        do {
            atomicIntegerFieldUpdater = f13317;
            i2 = atomicIntegerFieldUpdater.get(this);
            int i3 = i2 >> 29;
            if (i3 != 0) {
                if (i3 != 1) {
                    ᵕᵩʽᵲ.ᵪᵹᵥᵻ("Already resumed");
                    return;
                }
                boolean z = i == 4;
                InterfaceC2643 interfaceC2643 = this.f13319;
                if (!z && (interfaceC2643 instanceof C4295)) {
                    boolean z2 = i == 1 || i == 2;
                    int i4 = this.f3575;
                    if (z2 == (i4 == 1 || i4 == 2)) {
                        C4295 c4295 = (C4295) interfaceC2643;
                        AbstractC2071 abstractC2071 = c4295.f16368;
                        InterfaceC3822 interfaceC3822Mo1376 = c4295.f16369.mo1376();
                        if (AbstractC5016.m10350(abstractC2071, interfaceC3822Mo1376)) {
                            AbstractC5016.m10349(abstractC2071, interfaceC3822Mo1376, this);
                            return;
                        }
                        AbstractC4712 abstractC4712M6130 = AbstractC2412.m6130();
                        if (abstractC4712M6130.f17952 >= 4294967296L) {
                            abstractC4712M6130.m9862(this);
                            return;
                        }
                        abstractC4712M6130.m9861(true);
                        try {
                            ᵸˊʾᵜ.ᵠˏˏ(this, interfaceC2643, true);
                            do {
                            } while (abstractC4712M6130.m9860());
                        } finally {
                            try {
                            } finally {
                            }
                        }
                        return;
                    }
                }
                ᵸˊʾᵜ.ᵠˏˏ(this, interfaceC2643, z);
                return;
            }
        } while (!atomicIntegerFieldUpdater.compareAndSet(this, i2, 1073741824 + (536870911 & i2)));
    }

    /* JADX INFO: renamed from: ˉᵵᵜ, reason: contains not printable characters */
    public final void m7872(AbstractC2071 abstractC2071) {
        InterfaceC2643 interfaceC2643 = this.f13319;
        C4295 c4295 = interfaceC2643 instanceof C4295 ? (C4295) interfaceC2643 : null;
        m7882(C5063.f19112, (c4295 != null ? c4295.f16368 : null) == abstractC2071 ? 4 : this.f3575, null);
    }

    /* JADX INFO: renamed from: ˊᵙᵾᵲ, reason: contains not printable characters */
    public final void m7873() {
        InterfaceC0083 interfaceC0083M7874 = m7874();
        if (interfaceC0083M7874 == null) {
            return;
        }
        interfaceC0083M7874.mo1023();
        f13315.getClass();
        AbstractC1929.f7689.putObjectVolatile(this, f13318, C2751.f10576);
    }

    /* JADX INFO: renamed from: ˊᵨᵧ, reason: contains not printable characters */
    public final InterfaceC0083 m7874() {
        f13315.getClass();
        return (InterfaceC0083) AbstractC1929.f7689.getObjectVolatile(this, f13318);
    }

    @Override // defpackage.AbstractC0795
    /* JADX INFO: renamed from: ˊᵫᵗ */
    public final Object mo2886(Object obj) {
        return obj instanceof C5281 ? ((C5281) obj).f19939 : obj;
    }

    @Override // defpackage.InterfaceC0573
    /* JADX INFO: renamed from: ˋˈ */
    public final void mo2190(Object obj, InterfaceC4400 interfaceC4400) throws DispatchException {
        m7882(obj, this.f3575, interfaceC4400);
    }

    /* JADX INFO: renamed from: ˌᴵ, reason: contains not printable characters */
    public final Object m7875() {
        AtomicIntegerFieldUpdater atomicIntegerFieldUpdater;
        int i;
        InterfaceC4645 interfaceC4645;
        boolean zM7870 = m7870();
        do {
            atomicIntegerFieldUpdater = f13317;
            i = atomicIntegerFieldUpdater.get(this);
            int i2 = i >> 29;
            if (i2 != 0) {
                if (i2 != 2) {
                    ᵕᵩʽᵲ.ᵪᵹᵥᵻ("Already suspended");
                    return null;
                }
                if (zM7870) {
                    m7877();
                }
                Object objM7879 = m7879();
                if (objM7879 instanceof C5507) {
                    throw ((C5507) objM7879).f20800;
                }
                int i3 = this.f3575;
                if ((i3 != 1 && i3 != 2) || (interfaceC4645 = (InterfaceC4645) this.f13320.mo2664(C3664.f13909)) == null || interfaceC4645.mo6080()) {
                    return mo2886(objM7879);
                }
                CancellationException cancellationExceptionMo6083 = interfaceC4645.mo6083();
                mo2885(cancellationExceptionMo6083);
                throw cancellationExceptionMo6083;
            }
        } while (!atomicIntegerFieldUpdater.compareAndSet(this, i, 536870912 + (536870911 & i)));
        if (m7874() == null) {
            m7883();
        }
        if (zM7870) {
            m7877();
        }
        return EnumC0111.f1384;
    }

    /* JADX INFO: renamed from: ˏːˆ, reason: contains not printable characters */
    public Throwable mo7876(C2374 c2374) {
        return c2374.mo6083();
    }

    @Override // defpackage.AbstractC0795
    /* JADX INFO: renamed from: ːˏᵟᵯ */
    public final InterfaceC2643 mo2887() {
        return this.f13319;
    }

    /* JADX INFO: renamed from: ˑˊᵲ, reason: contains not printable characters */
    public final void m7877() throws DispatchException {
        Throwable thM9272;
        InterfaceC2643 interfaceC2643 = this.f13319;
        C4295 c4295 = interfaceC2643 instanceof C4295 ? (C4295) interfaceC2643 : null;
        if (c4295 == null || (thM9272 = c4295.m9272(this)) == null) {
            return;
        }
        m7873();
        m7885(thM9272);
    }

    /* JADX INFO: renamed from: ᵔᵖᵹᵫ, reason: contains not printable characters */
    public final void m7878() {
        InterfaceC0083 interfaceC0083M7883 = m7883();
        if (interfaceC0083M7883 == null || (m7879() instanceof InterfaceC2347)) {
            return;
        }
        interfaceC0083M7883.mo1023();
        f13315.getClass();
        AbstractC1929.f7689.putObjectVolatile(this, f13318, C2751.f10576);
    }

    /* JADX INFO: renamed from: ᵜᵪʾ, reason: contains not printable characters */
    public final Object m7879() {
        f13314.getClass();
        return AbstractC1929.f7689.getObjectVolatile(this, f13316);
    }

    /* JADX INFO: renamed from: ᵝᵶ, reason: contains not printable characters */
    public final void m7880(InterfaceC4400 interfaceC4400, Throwable th, Object obj) {
        InterfaceC3822 interfaceC3822 = this.f13320;
        try {
            interfaceC4400.mo1175(th, obj, interfaceC3822);
        } catch (Throwable th2) {
            AbstractC3481.m7941(interfaceC3822, new CompletionHandlerException("Exception in resume onCancellation handler for " + this, th2));
        }
    }

    /* JADX INFO: renamed from: ᵟᵹᵙ, reason: contains not printable characters */
    public final void m7881(AbstractC4709 abstractC4709, Throwable th) {
        InterfaceC3822 interfaceC3822 = this.f13320;
        int i = f13317.get(this) & 536870911;
        if (i == 536870911) {
            ᵕᵩʽᵲ.ᵪᵹᵥᵻ("The index for Segment.onCancellation(..) is broken");
            return;
        }
        try {
            abstractC4709.mo4079(i, interfaceC3822);
        } catch (Throwable th2) {
            AbstractC3481.m7941(interfaceC3822, new CompletionHandlerException("Exception in invokeOnCancellation handler for " + this, th2));
        }
    }

    /* JADX INFO: renamed from: ᵠˏˏ, reason: contains not printable characters */
    public final void m7882(Object obj, int i, InterfaceC4400 interfaceC4400) throws DispatchException {
        C3453 c3453;
        while (true) {
            f13314.getClass();
            Unsafe unsafe = AbstractC1929.f7689;
            long j = f13316;
            Object objectVolatile = unsafe.getObjectVolatile(this, j);
            if (!(objectVolatile instanceof InterfaceC2347)) {
                C3453 c34532 = this;
                if (objectVolatile instanceof C0190) {
                    C0190 c0190 = (C0190) objectVolatile;
                    if (C0190.f1634.compareAndSet(c0190, 0, 1)) {
                        if (interfaceC4400 != null) {
                            c34532.m7880(interfaceC4400, c0190.f20800, obj);
                            return;
                        }
                        return;
                    }
                }
                C3226.m7364(obj, "Already resumed, but proposed with update ");
                return;
            }
            Object objM7866 = m7866((InterfaceC2347) objectVolatile, obj, i, interfaceC4400);
            while (true) {
                Unsafe unsafe2 = AbstractC1929.f7689;
                c3453 = this;
                if (unsafe2.compareAndSwapObject(c3453, f13316, objectVolatile, objM7866)) {
                    if (!c3453.m7870()) {
                        c3453.m7873();
                    }
                    c3453.m7871(i);
                    return;
                } else if (unsafe2.getObjectVolatile(c3453, j) != objectVolatile) {
                    break;
                } else {
                    this = c3453;
                }
            }
            this = c3453;
        }
    }

    @Override // defpackage.InterfaceC2643
    /* JADX INFO: renamed from: ᵨᵣ */
    public final void mo3530(Object obj) throws DispatchException {
        Throwable thM5818 = AbstractC2231.m5818(obj);
        if (thM5818 != null) {
            obj = new C5507(thM5818, false);
        }
        m7882(obj, this.f3575, null);
    }

    /* JADX INFO: renamed from: ᵨᵼⁱ, reason: contains not printable characters */
    public final InterfaceC0083 m7883() {
        InterfaceC4645 interfaceC4645 = (InterfaceC4645) this.f13320.mo2664(C3664.f13909);
        if (interfaceC4645 == null) {
            return null;
        }
        InterfaceC0083 interfaceC0083M7957 = AbstractC3481.m7957(interfaceC4645, true, new C4238(this));
        while (true) {
            f13315.getClass();
            Unsafe unsafe = AbstractC1929.f7689;
            long j = f13318;
            C3453 c3453 = this;
            if (unsafe.compareAndSwapObject(c3453, j, (Object) null, interfaceC0083M7957) || unsafe.getObjectVolatile(c3453, j) != null) {
                break;
            }
            this = c3453;
        }
        return interfaceC0083M7957;
    }

    @Override // defpackage.InterfaceC0573
    /* JADX INFO: renamed from: ᵪᵹᵥᵻ */
    public final void mo2191(Object obj) throws DispatchException {
        m7871(this.f3575);
    }

    @Override // defpackage.InterfaceC2643
    /* JADX INFO: renamed from: ᵮᵣᵗˈ */
    public final InterfaceC3822 mo1376() {
        return this.f13320;
    }

    /* JADX INFO: renamed from: ᵯᵷʽ, reason: contains not printable characters */
    public final void m7884(InterfaceC0778 interfaceC0778) {
        m7886(new C1780(1, interfaceC0778));
    }

    /* JADX INFO: renamed from: ᵱʡˏ, reason: contains not printable characters */
    public final boolean m7885(Throwable th) throws DispatchException {
        Throwable cancellationException;
        C3453 c3453;
        while (true) {
            f13314.getClass();
            Unsafe unsafe = AbstractC1929.f7689;
            long j = f13316;
            Object objectVolatile = unsafe.getObjectVolatile(this, j);
            if (!(objectVolatile instanceof InterfaceC2347)) {
                return false;
            }
            boolean z = (objectVolatile instanceof InterfaceC5450) || (objectVolatile instanceof AbstractC4709);
            if (th == null) {
                cancellationException = new CancellationException("Continuation " + this + " was cancelled normally");
            } else {
                cancellationException = th;
            }
            C0190 c0190 = new C0190(cancellationException, z);
            while (true) {
                Unsafe unsafe2 = AbstractC1929.f7689;
                c3453 = this;
                if (unsafe2.compareAndSwapObject(c3453, f13316, objectVolatile, c0190)) {
                    InterfaceC2347 interfaceC2347 = (InterfaceC2347) objectVolatile;
                    if (interfaceC2347 instanceof InterfaceC5450) {
                        c3453.m7887((InterfaceC5450) objectVolatile, th);
                    } else if (interfaceC2347 instanceof AbstractC4709) {
                        c3453.m7881((AbstractC4709) objectVolatile, th);
                    }
                    if (!c3453.m7870()) {
                        c3453.m7873();
                    }
                    c3453.m7871(c3453.f3575);
                    return true;
                }
                if (unsafe2.getObjectVolatile(c3453, j) != objectVolatile) {
                    break;
                }
                this = c3453;
            }
            this = c3453;
        }
    }

    @Override // defpackage.AbstractC0795
    /* JADX INFO: renamed from: ᵱᵽʡᵚ */
    public final Object mo2888() {
        return m7879();
    }

    @Override // defpackage.InterfaceC2973
    /* JADX INFO: renamed from: ᵲᵶᵳˈ */
    public final void mo3792(AbstractC4709 abstractC4709, int i) {
        AtomicIntegerFieldUpdater atomicIntegerFieldUpdater;
        int i2;
        do {
            atomicIntegerFieldUpdater = f13317;
            i2 = atomicIntegerFieldUpdater.get(this);
            if ((i2 & 536870911) != 536870911) {
                ᵕᵩʽᵲ.ᵪᵹᵥᵻ("invokeOnCancellation should be called at most once");
                return;
            }
        } while (!atomicIntegerFieldUpdater.compareAndSet(this, i2, ((i2 >> 29) << 29) + i));
        m7886(abstractC4709);
    }

    @Override // defpackage.InterfaceC0573
    /* JADX INFO: renamed from: ᵵᵽ */
    public final C1735 mo2192(Object obj, InterfaceC4400 interfaceC4400) {
        return m7869(obj, interfaceC4400);
    }

    /* JADX WARN: Code restructure failed: missing block: B:60:0x00c5, code lost:
    
        m7867(r11, r7);
     */
    /* JADX WARN: Code restructure failed: missing block: B:61:0x00c8, code lost:
    
        throw null;
     */
    /* JADX INFO: renamed from: ᵶˇᵱ, reason: contains not printable characters */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public final void m7886(InterfaceC2347 interfaceC2347) {
        C3453 c3453;
        Unsafe unsafe;
        C3453 c34532;
        while (true) {
            f13314.getClass();
            Unsafe unsafe2 = AbstractC1929.f7689;
            long j = f13316;
            Object objectVolatile = unsafe2.getObjectVolatile(this, j);
            if (objectVolatile instanceof C1778) {
                while (true) {
                    Unsafe unsafe3 = AbstractC1929.f7689;
                    c3453 = this;
                    if (unsafe3.compareAndSwapObject(c3453, f13316, objectVolatile, interfaceC2347)) {
                        return;
                    }
                    if (unsafe3.getObjectVolatile(c3453, j) != objectVolatile) {
                        break;
                    } else {
                        this = c3453;
                    }
                }
            } else {
                c3453 = this;
                if ((objectVolatile instanceof InterfaceC5450) || (objectVolatile instanceof AbstractC4709)) {
                    break;
                }
                if (objectVolatile instanceof C5507) {
                    C5507 c5507 = (C5507) objectVolatile;
                    if (!C5507.f20799.compareAndSet(c5507, 0, 1)) {
                        m7867(interfaceC2347, objectVolatile);
                        throw null;
                    }
                    if (objectVolatile instanceof C0190) {
                        Throwable th = c5507.f20800;
                        if (interfaceC2347 instanceof InterfaceC5450) {
                            c3453.m7887((InterfaceC5450) interfaceC2347, th);
                            return;
                        } else {
                            c3453.m7881((AbstractC4709) interfaceC2347, th);
                            return;
                        }
                    }
                    return;
                }
                if (objectVolatile instanceof C5281) {
                    C5281 c5281 = (C5281) objectVolatile;
                    if (c5281.f19936 != null) {
                        m7867(interfaceC2347, objectVolatile);
                        throw null;
                    }
                    if (interfaceC2347 instanceof AbstractC4709) {
                        return;
                    }
                    InterfaceC5450 interfaceC5450 = (InterfaceC5450) interfaceC2347;
                    Throwable th2 = c5281.f19938;
                    if (th2 != null) {
                        c3453.m7887(interfaceC5450, th2);
                        return;
                    }
                    C5281 c5281M10875 = C5281.m10875(c5281, interfaceC5450, null, 29);
                    do {
                        unsafe = AbstractC1929.f7689;
                        c34532 = c3453;
                        if (unsafe.compareAndSwapObject(c3453, f13316, objectVolatile, c5281M10875)) {
                            return;
                        } else {
                            c3453 = c34532;
                        }
                    } while (unsafe.getObjectVolatile(c34532, j) == objectVolatile);
                } else {
                    C3453 c34533 = c3453;
                    if (interfaceC2347 instanceof AbstractC4709) {
                        return;
                    }
                    C5281 c52812 = new C5281(objectVolatile, (InterfaceC5450) interfaceC2347, (InterfaceC4400) null, (Throwable) null, 28);
                    while (true) {
                        C5281 c52813 = c52812;
                        Unsafe unsafe4 = AbstractC1929.f7689;
                        c3453 = c34533;
                        boolean zCompareAndSwapObject = unsafe4.compareAndSwapObject(c3453, f13316, objectVolatile, c52813);
                        c52812 = c52813;
                        if (zCompareAndSwapObject) {
                            return;
                        }
                        if (unsafe4.getObjectVolatile(c3453, j) != objectVolatile) {
                            break;
                        } else {
                            c34533 = c3453;
                        }
                    }
                }
            }
            this = c3453;
        }
    }

    /* JADX INFO: renamed from: ᵶᵥᵝ, reason: contains not printable characters */
    public final void m7887(InterfaceC5450 interfaceC5450, Throwable th) {
        try {
            interfaceC5450.mo2991(th);
        } catch (Throwable th2) {
            AbstractC3481.m7941(this.f13320, new CompletionHandlerException("Exception in invokeOnCancellation handler for " + this, th2));
        }
    }

    @Override // defpackage.InterfaceC3912
    /* JADX INFO: renamed from: ᵷᵺʾᵖ */
    public final InterfaceC3912 mo1379() {
        InterfaceC2643 interfaceC2643 = this.f13319;
        if (interfaceC2643 instanceof InterfaceC3912) {
            return (InterfaceC3912) interfaceC2643;
        }
        return null;
    }

    /* JADX INFO: renamed from: ᵸˆˁ, reason: contains not printable characters */
    public String mo7888() {
        return "CancellableContinuation";
    }

    @Override // defpackage.AbstractC0795
    /* JADX INFO: renamed from: ᵻˈᵦʼ */
    public final Throwable mo2890(Object obj) {
        Throwable thMo2890 = super.mo2890(obj);
        if (thMo2890 != null) {
            return thMo2890;
        }
        return null;
    }
}