package defpackage;

import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
import sun.misc.Unsafe;

/* JADX INFO: renamed from: ᵖˏːᵬ, reason: contains not printable characters */
/* JADX INFO: loaded from: classes3.dex */
public final class C2415 extends C1461 implements InterfaceC0260 {
    private volatile /* synthetic */ Object owner$volatile;

    /* JADX INFO: renamed from: ˑˊᵲ, reason: contains not printable characters */
    public static final /* synthetic */ AtomicReferenceFieldUpdater f9413 = AtomicReferenceFieldUpdater.newUpdater(C2415.class, Object.class, "owner$volatile");

    /* JADX INFO: renamed from: ʿٴˇ, reason: contains not printable characters */
    public static final /* synthetic */ long f9412 = AbstractC1929.f7689.objectFieldOffset(C2415.class.getDeclaredField("owner$volatile"));

    public C2415() {
        super(1);
        this.owner$volatile = AbstractC2944.f11337;
    }

    public final String toString() {
        StringBuilder sb = new StringBuilder("Mutex@");
        sb.append(ᵹˊᵫˋ.ᵶᵥᵝ(this));
        sb.append("[isLocked=");
        sb.append(mo1476());
        sb.append(",owner=");
        f9413.getClass();
        sb.append(AbstractC1929.f7689.getObjectVolatile(this, f9412));
        sb.append(']');
        return sb.toString();
    }

    /* JADX INFO: renamed from: ˊᵫᵗ, reason: contains not printable characters */
    public final int m6131() {
        int i;
        while (true) {
            AtomicIntegerFieldUpdater atomicIntegerFieldUpdater = C1461.f5937;
            int i2 = atomicIntegerFieldUpdater.get(this);
            int i3 = this.f5944;
            if (i2 > i3) {
                do {
                    i = atomicIntegerFieldUpdater.get(this);
                    if (i > i3) {
                    }
                } while (!atomicIntegerFieldUpdater.compareAndSet(this, i, i3));
            } else {
                if (i2 <= 0) {
                    return 1;
                }
                if (atomicIntegerFieldUpdater.compareAndSet(this, i2, i2 - 1)) {
                    f9413.getClass();
                    AbstractC1929.f7689.putObjectVolatile(this, f9412, (Object) null);
                    return 0;
                }
            }
        }
    }

    @Override // defpackage.InterfaceC0260
    /* JADX INFO: renamed from: ːˏᵟᵯ */
    public final boolean mo1476() {
        return Math.max(C1461.f5937.get(this), 0) == 0;
    }

    @Override // defpackage.InterfaceC0260
    /* JADX INFO: renamed from: ᵟᵹᵙ */
    public final void mo1477(Object obj) {
        while (this.mo1476()) {
            f9413.getClass();
            Unsafe unsafe = AbstractC1929.f7689;
            long j = f9412;
            Object objectVolatile = unsafe.getObjectVolatile(this, j);
            C1735 c1735 = AbstractC2944.f11337;
            if (objectVolatile != c1735) {
                if (objectVolatile != obj && obj != null) {
                    throw new IllegalStateException(("This mutex is locked by " + objectVolatile + ", but " + obj + " is expected").toString());
                }
                while (true) {
                    Unsafe unsafe2 = AbstractC1929.f7689;
                    C2415 c2415 = this;
                    if (unsafe2.compareAndSwapObject(c2415, f9412, objectVolatile, c1735)) {
                        c2415.m4184();
                        return;
                    } else {
                        if (unsafe2.getObjectVolatile(c2415, j) != objectVolatile) {
                            this = c2415;
                            break;
                        }
                        this = c2415;
                    }
                }
            }
        }
        ᵕᵩʽᵲ.ᵪᵹᵥᵻ("This mutex is not locked");
    }

    /* JADX WARN: Code restructure failed: missing block: B:10:0x0022, code lost:
    
        r5 = defpackage.C2415.f9413;
        r2 = r0.f5850;
        r5.set(r2, null);
        r5 = r0.f5849;
        r5.m7882(r1, r5.f3575, new ᵦˀˈᵨ(1, new ᵨˈʼﹶ(r2, r0)));
     */
    @Override // defpackage.InterfaceC0260
    /* JADX INFO: renamed from: ᵲᵶᵳˈ */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public final Object mo1478(AbstractC3500 abstractC3500) {
        boolean zM6132 = m6132();
        C5063 c5063 = C5063.f19112;
        if (!zM6132) {
            C3453 c3453 = ᵹˊᵫˋ.ˋˈ(ˌᵨʽʙ.ᵔᵖᵹᵫ(abstractC3500));
            try {
                C1426 c1426 = new C1426(this, c3453);
                while (true) {
                    int andDecrement = C1461.f5937.getAndDecrement(this);
                    if (andDecrement <= this.f5944) {
                        if (andDecrement > 0) {
                            break;
                        }
                        if (m4185(c1426)) {
                            break;
                        }
                    }
                }
                Object objM7875 = c3453.m7875();
                EnumC0111 enumC0111 = EnumC0111.f1384;
                if (objM7875 != enumC0111) {
                    objM7875 = c5063;
                }
                if (objM7875 == enumC0111) {
                    return objM7875;
                }
            } catch (Throwable th) {
                c3453.m7877();
                throw th;
            }
        }
        return c5063;
    }

    /* JADX INFO: renamed from: ᵵᵽ, reason: contains not printable characters */
    public final boolean m6132() {
        int iM6131 = m6131();
        if (iM6131 == 0) {
            return true;
        }
        if (iM6131 == 1) {
            return false;
        }
        if (iM6131 == 2) {
            throw new IllegalStateException("This mutex is already locked by the specified owner: null".toString());
        }
        ᵕᵩʽᵲ.ᵪᵹᵥᵻ("unexpected");
        return false;
    }
}