package defpackage;

import androidx.credentials.provider.CredentialEntry;
import androidx.media3.exoplayer.upstream.CmcdData;
import com.google.android.gms.measurement.api.AppMeasurementSdk;
import java.lang.reflect.Field;
import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import java.util.Locale;
import java.util.Objects;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
import java.util.concurrent.locks.LockSupport;
import java.util.logging.Level;
import java.util.logging.Logger;
import sun.misc.Unsafe;

/* JADX INFO: loaded from: classes2.dex */
@az3
@lw7
@ii2
public abstract class ca<V> extends jq4 implements zb5<V> {
    private static final b ATOMIC_HELPER;
    static final boolean GENERATE_CANCELLATION_CAUSES;
    private static final Object NULL;
    private static final long SPIN_THRESHOLD_NANOS = 1000;
    static final y65 log;

    @ez0
    private volatile e listeners;

    @ez0
    private volatile Object value;

    @ez0
    private volatile l waiters;

    public static abstract class b {
        public abstract boolean a(ca caVar, e eVar, e eVar2);

        public abstract boolean b(ca caVar, Object obj, Object obj2);

        public abstract boolean c(ca caVar, l lVar, l lVar2);

        public abstract e d(ca caVar);

        public abstract l e(ca caVar);

        public abstract void f(l lVar, l lVar2);

        public abstract void g(l lVar, Thread thread);
    }

    public static final class c {
        public static final c c;
        public static final c d;
        public final boolean a;
        public final Throwable b;

        static {
            if (ca.GENERATE_CANCELLATION_CAUSES) {
                d = null;
                c = null;
            } else {
                d = new c(null, false);
                c = new c(null, true);
            }
        }

        public c(Throwable th, boolean z) {
            this.a = z;
            this.b = th;
        }
    }

    public static final class d {
        public static final d b = new d(new a("Failure occurred while trying to finish a future."));
        public final Throwable a;

        public class a extends Throwable {
            @Override // java.lang.Throwable
            public final synchronized Throwable fillInStackTrace() {
                return this;
            }
        }

        public d(Throwable th) {
            th.getClass();
            this.a = th;
        }
    }

    public static final class f extends b {
        public final AtomicReferenceFieldUpdater a;
        public final AtomicReferenceFieldUpdater b;
        public final AtomicReferenceFieldUpdater c;
        public final AtomicReferenceFieldUpdater d;
        public final AtomicReferenceFieldUpdater e;

        public f(AtomicReferenceFieldUpdater atomicReferenceFieldUpdater, AtomicReferenceFieldUpdater atomicReferenceFieldUpdater2, AtomicReferenceFieldUpdater atomicReferenceFieldUpdater3, AtomicReferenceFieldUpdater atomicReferenceFieldUpdater4, AtomicReferenceFieldUpdater atomicReferenceFieldUpdater5) {
            this.a = atomicReferenceFieldUpdater;
            this.b = atomicReferenceFieldUpdater2;
            this.c = atomicReferenceFieldUpdater3;
            this.d = atomicReferenceFieldUpdater4;
            this.e = atomicReferenceFieldUpdater5;
        }

        @Override // ca.b
        public final boolean a(ca caVar, e eVar, e eVar2) {
            AtomicReferenceFieldUpdater atomicReferenceFieldUpdater;
            do {
                atomicReferenceFieldUpdater = this.d;
                if (atomicReferenceFieldUpdater.compareAndSet(caVar, eVar, eVar2)) {
                    return true;
                }
            } while (atomicReferenceFieldUpdater.get(caVar) == eVar);
            return false;
        }

        @Override // ca.b
        public final boolean b(ca caVar, Object obj, Object obj2) {
            AtomicReferenceFieldUpdater atomicReferenceFieldUpdater;
            do {
                atomicReferenceFieldUpdater = this.e;
                if (atomicReferenceFieldUpdater.compareAndSet(caVar, obj, obj2)) {
                    return true;
                }
            } while (atomicReferenceFieldUpdater.get(caVar) == obj);
            return false;
        }

        @Override // ca.b
        public final boolean c(ca caVar, l lVar, l lVar2) {
            AtomicReferenceFieldUpdater atomicReferenceFieldUpdater;
            do {
                atomicReferenceFieldUpdater = this.c;
                if (atomicReferenceFieldUpdater.compareAndSet(caVar, lVar, lVar2)) {
                    return true;
                }
            } while (atomicReferenceFieldUpdater.get(caVar) == lVar);
            return false;
        }

        @Override // ca.b
        public final e d(ca caVar) {
            return (e) this.d.getAndSet(caVar, e.d);
        }

        @Override // ca.b
        public final l e(ca caVar) {
            return (l) this.c.getAndSet(caVar, l.c);
        }

        @Override // ca.b
        public final void f(l lVar, l lVar2) {
            this.b.lazySet(lVar, lVar2);
        }

        @Override // ca.b
        public final void g(l lVar, Thread thread) {
            this.a.lazySet(lVar, thread);
        }
    }

    public static final class g<V> implements Runnable {
        public final ca a;
        public final zb5 b;

        public g(ca caVar, zb5 zb5Var) {
            this.a = caVar;
            this.b = zb5Var;
        }

        @Override // java.lang.Runnable
        public final void run() {
            ca caVar = this.a;
            if (caVar.value != this) {
                return;
            }
            if (ca.ATOMIC_HELPER.b(caVar, this, ca.f(this.b))) {
                ca.c(caVar, false);
            }
        }
    }

    public static final class h extends b {
        @Override // ca.b
        public final boolean a(ca caVar, e eVar, e eVar2) {
            synchronized (caVar) {
                try {
                    if (caVar.listeners != eVar) {
                        return false;
                    }
                    caVar.listeners = eVar2;
                    return true;
                } catch (Throwable th) {
                    throw th;
                }
            }
        }

        @Override // ca.b
        public final boolean b(ca caVar, Object obj, Object obj2) {
            synchronized (caVar) {
                try {
                    if (caVar.value != obj) {
                        return false;
                    }
                    caVar.value = obj2;
                    return true;
                } catch (Throwable th) {
                    throw th;
                }
            }
        }

        @Override // ca.b
        public final boolean c(ca caVar, l lVar, l lVar2) {
            synchronized (caVar) {
                try {
                    if (caVar.waiters != lVar) {
                        return false;
                    }
                    caVar.waiters = lVar2;
                    return true;
                } catch (Throwable th) {
                    throw th;
                }
            }
        }

        @Override // ca.b
        public final e d(ca caVar) {
            e eVar;
            e eVar2 = e.d;
            synchronized (caVar) {
                try {
                    eVar = caVar.listeners;
                    if (eVar != eVar2) {
                        caVar.listeners = eVar2;
                    }
                } catch (Throwable th) {
                    throw th;
                }
            }
            return eVar;
        }

        @Override // ca.b
        public final l e(ca caVar) {
            l lVar;
            l lVar2 = l.c;
            synchronized (caVar) {
                try {
                    lVar = caVar.waiters;
                    if (lVar != lVar2) {
                        caVar.waiters = lVar2;
                    }
                } catch (Throwable th) {
                    throw th;
                }
            }
            return lVar;
        }

        @Override // ca.b
        public final void f(l lVar, l lVar2) {
            lVar.b = lVar2;
        }

        @Override // ca.b
        public final void g(l lVar, Thread thread) {
            lVar.a = thread;
        }
    }

    public interface i<V> extends zb5<V> {
    }

    public static abstract class j<V> extends ca<V> implements i<V> {
    }

    public static final class k extends b {
        public static final Unsafe a;
        public static final long b;
        public static final long c;
        public static final long d;
        public static final long e;
        public static final long f;

        public class a implements PrivilegedExceptionAction<Unsafe> {
            public static Unsafe a() throws IllegalAccessException {
                for (Field field : Unsafe.class.getDeclaredFields()) {
                    field.setAccessible(true);
                    Object obj = field.get(null);
                    if (Unsafe.class.isInstance(obj)) {
                        return (Unsafe) Unsafe.class.cast(obj);
                    }
                }
                throw new NoSuchFieldError("the Unsafe");
            }

            @Override // java.security.PrivilegedExceptionAction
            public final /* bridge */ /* synthetic */ Unsafe run() {
                return a();
            }
        }

        static {
            Unsafe unsafe;
            try {
                try {
                    unsafe = Unsafe.getUnsafe();
                } catch (PrivilegedActionException e2) {
                    throw new RuntimeException("Could not initialize intrinsics", e2.getCause());
                }
            } catch (SecurityException unused) {
                unsafe = (Unsafe) AccessController.doPrivileged(new a());
            }
            try {
                c = unsafe.objectFieldOffset(ca.class.getDeclaredField("waiters"));
                b = unsafe.objectFieldOffset(ca.class.getDeclaredField("listeners"));
                d = unsafe.objectFieldOffset(ca.class.getDeclaredField(AppMeasurementSdk.ConditionalUserProperty.VALUE));
                e = unsafe.objectFieldOffset(l.class.getDeclaredField(CmcdData.OBJECT_TYPE_AUDIO_ONLY));
                f = unsafe.objectFieldOffset(l.class.getDeclaredField("b"));
                a = unsafe;
            } catch (NoSuchFieldException e3) {
                throw new RuntimeException(e3);
            }
        }

        @Override // ca.b
        public final boolean a(ca caVar, e eVar, e eVar2) {
            return bz.a(a, caVar, b, eVar, eVar2);
        }

        @Override // ca.b
        public final boolean b(ca caVar, Object obj, Object obj2) {
            return bz.a(a, caVar, d, obj, obj2);
        }

        @Override // ca.b
        public final boolean c(ca caVar, l lVar, l lVar2) {
            return bz.a(a, caVar, c, lVar, lVar2);
        }

        @Override // ca.b
        public final e d(ca caVar) {
            e eVar;
            e eVar2;
            do {
                eVar = caVar.listeners;
                eVar2 = e.d;
                if (eVar2 == eVar) {
                    break;
                }
            } while (!a(caVar, eVar, eVar2));
            return eVar;
        }

        @Override // ca.b
        public final l e(ca caVar) {
            l lVar;
            l lVar2;
            do {
                lVar = caVar.waiters;
                lVar2 = l.c;
                if (lVar2 == lVar) {
                    break;
                }
            } while (!c(caVar, lVar, lVar2));
            return lVar;
        }

        @Override // ca.b
        public final void f(l lVar, l lVar2) {
            a.putObject(lVar, f, lVar2);
        }

        @Override // ca.b
        public final void g(l lVar, Thread thread) {
            a.putObject(lVar, e, thread);
        }
    }

    public static final class l {
        public static final l c = new l();
        public volatile Thread a;
        public volatile l b;

        public l() {
            ca.ATOMIC_HELPER.g(this, Thread.currentThread());
        }
    }

    static {
        boolean z;
        Throwable th;
        b hVar;
        try {
            z = Boolean.parseBoolean(System.getProperty("guava.concurrent.generate_cancellation_cause", CredentialEntry.FALSE_STRING));
        } catch (SecurityException unused) {
            z = false;
        }
        GENERATE_CANCELLATION_CAUSES = z;
        log = new y65(ca.class);
        Throwable th2 = null;
        try {
            hVar = new k();
            th = null;
        } catch (Error | Exception e2) {
            th = e2;
            try {
                hVar = new f(AtomicReferenceFieldUpdater.newUpdater(l.class, Thread.class, CmcdData.OBJECT_TYPE_AUDIO_ONLY), AtomicReferenceFieldUpdater.newUpdater(l.class, l.class, "b"), AtomicReferenceFieldUpdater.newUpdater(ca.class, l.class, "waiters"), AtomicReferenceFieldUpdater.newUpdater(ca.class, e.class, "listeners"), AtomicReferenceFieldUpdater.newUpdater(ca.class, Object.class, AppMeasurementSdk.ConditionalUserProperty.VALUE));
            } catch (Error | Exception e3) {
                th2 = e3;
                hVar = new h();
            }
        }
        ATOMIC_HELPER = hVar;
        if (th2 != null) {
            y65 y65Var = log;
            Logger loggerA = y65Var.a();
            Level level = Level.SEVERE;
            loggerA.log(level, "UnsafeAtomicHelper is broken!", th);
            y65Var.a().log(level, "SafeAtomicHelper is broken!", th2);
        }
        NULL = new Object();
    }

    public static void c(ca caVar, boolean z) {
        e eVar = null;
        while (true) {
            caVar.getClass();
            for (l lVarE = ATOMIC_HELPER.e(caVar); lVarE != null; lVarE = lVarE.b) {
                Thread thread = lVarE.a;
                if (thread != null) {
                    lVarE.a = null;
                    LockSupport.unpark(thread);
                }
            }
            if (z) {
                caVar.interruptTask();
                z = false;
            }
            caVar.afterDone();
            e eVar2 = eVar;
            e eVarD = ATOMIC_HELPER.d(caVar);
            e eVar3 = eVar2;
            while (eVarD != null) {
                e eVar4 = eVarD.c;
                eVarD.c = eVar3;
                eVar3 = eVarD;
                eVarD = eVar4;
            }
            while (eVar3 != null) {
                eVar = eVar3.c;
                Runnable runnable = eVar3.a;
                Objects.requireNonNull(runnable);
                if (runnable instanceof g) {
                    g gVar = (g) runnable;
                    caVar = gVar.a;
                    if (caVar.value == gVar) {
                        if (ATOMIC_HELPER.b(caVar, gVar, f(gVar.b))) {
                            break;
                        }
                    } else {
                        continue;
                    }
                } else {
                    Executor executor = eVar3.b;
                    Objects.requireNonNull(executor);
                    d(runnable, executor);
                }
                eVar3 = eVar;
            }
            return;
        }
    }

    public static void d(Runnable runnable, Executor executor) {
        try {
            executor.execute(runnable);
        } catch (Exception e2) {
            log.a().log(Level.SEVERE, "RuntimeException while executing runnable " + runnable + " with executor " + executor, (Throwable) e2);
        }
    }

    public static Object e(Object obj) throws ExecutionException {
        if (obj instanceof c) {
            Throwable th = ((c) obj).b;
            CancellationException cancellationException = new CancellationException("Task was cancelled.");
            cancellationException.initCause(th);
            throw cancellationException;
        }
        if (obj instanceof d) {
            throw new ExecutionException(((d) obj).a);
        }
        if (obj == NULL) {
            return null;
        }
        return obj;
    }

    /* JADX WARN: Multi-variable type inference failed */
    public static Object f(zb5 zb5Var) {
        Object obj;
        Throwable thTryInternalFastPathGetFailure;
        if (zb5Var instanceof i) {
            Object cVar = ((ca) zb5Var).value;
            if (cVar instanceof c) {
                c cVar2 = (c) cVar;
                if (cVar2.a) {
                    cVar = cVar2.b != null ? new c(cVar2.b, false) : c.d;
                }
            }
            Objects.requireNonNull(cVar);
            return cVar;
        }
        if ((zb5Var instanceof jq4) && (thTryInternalFastPathGetFailure = ((jq4) zb5Var).tryInternalFastPathGetFailure()) != null) {
            return new d(thTryInternalFastPathGetFailure);
        }
        boolean zIsCancelled = zb5Var.isCancelled();
        boolean z = true;
        if ((!GENERATE_CANCELLATION_CAUSES) && zIsCancelled) {
            c cVar3 = c.d;
            Objects.requireNonNull(cVar3);
            return cVar3;
        }
        boolean z2 = false;
        while (true) {
            try {
                try {
                    try {
                        obj = zb5Var.get();
                        break;
                    } catch (Error e2) {
                        e = e2;
                        return new d(e);
                    }
                } catch (InterruptedException unused) {
                    z2 = z;
                } catch (Throwable th) {
                    if (z2) {
                        Thread.currentThread().interrupt();
                    }
                    throw th;
                }
            } catch (Error | Exception e3) {
                e = e3;
                return new d(e);
            } catch (CancellationException e4) {
                if (zIsCancelled) {
                    return new c(e4, false);
                }
                return new d(new IllegalArgumentException("get() threw CancellationException, despite reporting isCancelled() == false: " + zb5Var, e4));
            } catch (ExecutionException e5) {
                if (!zIsCancelled) {
                    return new d(e5.getCause());
                }
                return new c(new IllegalArgumentException("get() did not throw CancellationException, despite reporting isCancelled() == true: " + zb5Var, e5), false);
            }
        }
        if (z2) {
            Thread.currentThread().interrupt();
        }
        if (!zIsCancelled) {
            return obj == null ? NULL : obj;
        }
        return new c(new IllegalArgumentException("get() did not throw CancellationException, despite reporting isCancelled() == true: " + zb5Var), false);
    }

    public final void a(StringBuilder sb) {
        V v;
        boolean z = false;
        while (true) {
            try {
                try {
                    v = get();
                    break;
                } catch (InterruptedException unused) {
                    z = true;
                } catch (Throwable th) {
                    if (z) {
                        Thread.currentThread().interrupt();
                    }
                    throw th;
                }
            } catch (CancellationException unused2) {
                sb.append("CANCELLED");
                return;
            } catch (ExecutionException e2) {
                sb.append("FAILURE, cause=[");
                sb.append(e2.getCause());
                sb.append("]");
                return;
            } catch (Exception e3) {
                sb.append("UNKNOWN, cause=[");
                sb.append(e3.getClass());
                sb.append(" thrown from get()]");
                return;
            }
        }
        if (z) {
            Thread.currentThread().interrupt();
        }
        sb.append("SUCCESS, result=[");
        b(sb, v);
        sb.append("]");
    }

    @Override // defpackage.zb5
    public void addListener(Runnable runnable, Executor executor) {
        e eVar;
        e eVar2 = e.d;
        if7.l(runnable, "Runnable was null.");
        if7.l(executor, "Executor was null.");
        if (!isDone() && (eVar = this.listeners) != eVar2) {
            e eVar3 = new e(runnable, executor);
            do {
                eVar3.c = eVar;
                if (ATOMIC_HELPER.a(this, eVar, eVar3)) {
                    return;
                } else {
                    eVar = this.listeners;
                }
            } while (eVar != eVar2);
        }
        d(runnable, executor);
    }

    @oh3
    public void afterDone() {
    }

    public final void b(StringBuilder sb, Object obj) {
        if (obj == null) {
            sb.append("null");
        } else {
            if (obj == this) {
                sb.append("this future");
                return;
            }
            sb.append(obj.getClass().getName());
            sb.append("@");
            sb.append(Integer.toHexString(System.identityHashCode(obj)));
        }
    }

    @Override // java.util.concurrent.Future
    @hs0
    public boolean cancel(boolean z) {
        c cVar;
        Object obj = this.value;
        if (!(obj == null) && !(obj instanceof g)) {
            return false;
        }
        if (GENERATE_CANCELLATION_CAUSES) {
            cVar = new c(new CancellationException("Future.cancel() was called."), z);
        } else {
            cVar = z ? c.c : c.d;
            Objects.requireNonNull(cVar);
        }
        ca<V> caVar = this;
        boolean z2 = false;
        while (true) {
            if (ATOMIC_HELPER.b(caVar, obj, cVar)) {
                c(caVar, z);
                if (!(obj instanceof g)) {
                    break;
                }
                zb5 zb5Var = ((g) obj).b;
                if (!(zb5Var instanceof i)) {
                    zb5Var.cancel(z);
                    break;
                }
                caVar = (ca) zb5Var;
                obj = caVar.value;
                if (!(obj == null) && !(obj instanceof g)) {
                    break;
                }
                z2 = true;
            } else {
                obj = caVar.value;
                if (!(obj instanceof g)) {
                    return z2;
                }
            }
        }
        return true;
    }

    public final void g(l lVar) {
        lVar.a = null;
        while (true) {
            l lVar2 = this.waiters;
            if (lVar2 == l.c) {
                return;
            }
            l lVar3 = null;
            while (lVar2 != null) {
                l lVar4 = lVar2.b;
                if (lVar2.a != null) {
                    lVar3 = lVar2;
                } else if (lVar3 != null) {
                    lVar3.b = lVar4;
                    if (lVar3.a == null) {
                        break;
                    }
                } else if (!ATOMIC_HELPER.c(this, lVar2, lVar4)) {
                    break;
                }
                lVar2 = lVar4;
            }
            return;
        }
    }

    @Override // java.util.concurrent.Future
    @hs0
    @x17
    public V get(long j2, TimeUnit timeUnit) throws ExecutionException, InterruptedException, TimeoutException {
        boolean z;
        long j3;
        l lVar = l.c;
        long nanos = timeUnit.toNanos(j2);
        if (Thread.interrupted()) {
            throw new InterruptedException();
        }
        Object obj = this.value;
        if ((obj != null) && (!(obj instanceof g))) {
            return (V) e(obj);
        }
        long j4 = 0;
        long jNanoTime = nanos > 0 ? System.nanoTime() + nanos : 0L;
        if (nanos >= 1000) {
            l lVar2 = this.waiters;
            if (lVar2 != lVar) {
                l lVar3 = new l();
                z = true;
                while (true) {
                    ATOMIC_HELPER.f(lVar3, lVar2);
                    if (ATOMIC_HELPER.c(this, lVar2, lVar3)) {
                        j3 = j4;
                        do {
                            LockSupport.parkNanos(this, Math.min(nanos, 2147483647999999999L));
                            if (Thread.interrupted()) {
                                g(lVar3);
                                throw new InterruptedException();
                            }
                            Object obj2 = this.value;
                            if ((obj2 != null) && (!(obj2 instanceof g))) {
                                return (V) e(obj2);
                            }
                            nanos = jNanoTime - System.nanoTime();
                        } while (nanos >= 1000);
                        g(lVar3);
                    } else {
                        long j5 = j4;
                        lVar2 = this.waiters;
                        if (lVar2 == lVar) {
                            break;
                        }
                        j4 = j5;
                    }
                }
            }
            Object obj3 = this.value;
            Objects.requireNonNull(obj3);
            return (V) e(obj3);
        }
        z = true;
        j3 = 0;
        while (nanos > j3) {
            Object obj4 = this.value;
            if ((obj4 != null ? z : false) && (!(obj4 instanceof g))) {
                return (V) e(obj4);
            }
            if (Thread.interrupted()) {
                throw new InterruptedException();
            }
            nanos = jNanoTime - System.nanoTime();
        }
        String string = toString();
        String string2 = timeUnit.toString();
        Locale locale = Locale.ROOT;
        String lowerCase = string2.toLowerCase(locale);
        StringBuilder sbP = vw2.p(j2, "Waited ", " ");
        sbP.append(timeUnit.toString().toLowerCase(locale));
        String string3 = sbP.toString();
        if (nanos + 1000 < j3) {
            String strK = vw2.k(string3, " (plus ");
            long j6 = -nanos;
            long jConvert = timeUnit.convert(j6, TimeUnit.NANOSECONDS);
            long nanos2 = j6 - timeUnit.toNanos(jConvert);
            boolean z2 = (jConvert == j3 || nanos2 > 1000) ? z : false;
            if (jConvert > j3) {
                String strK2 = strK + jConvert + " " + lowerCase;
                if (z2) {
                    strK2 = vw2.k(strK2, ",");
                }
                strK = vw2.k(strK2, " ");
            }
            if (z2) {
                strK = strK + nanos2 + " nanoseconds ";
            }
            string3 = vw2.k(strK, "delay)");
        }
        if (isDone()) {
            throw new TimeoutException(vw2.k(string3, " but future completed as timeout expired"));
        }
        throw new TimeoutException(vw2.l(string3, " for ", string));
    }

    public void interruptTask() {
    }

    @Override // java.util.concurrent.Future
    public boolean isCancelled() {
        return this.value instanceof c;
    }

    @Override // java.util.concurrent.Future
    public boolean isDone() {
        return (!(r0 instanceof g)) & (this.value != null);
    }

    public final void maybePropagateCancellationTo(@ez0 Future<?> future) {
        if ((future != null) && isCancelled()) {
            future.cancel(wasInterrupted());
        }
    }

    /* JADX WARN: Multi-variable type inference failed */
    @ez0
    public String pendingToString() {
        if (!(this instanceof ScheduledFuture)) {
            return null;
        }
        return "remaining delay=[" + ((ScheduledFuture) this).getDelay(TimeUnit.MILLISECONDS) + " ms]";
    }

    /* JADX WARN: Type inference fix 'apply assigned field type' failed
    java.lang.UnsupportedOperationException: ArgType.getObject(), call class: class jadx.core.dex.instructions.args.ArgType$UnknownArg
    	at jadx.core.dex.instructions.args.ArgType.getObject(ArgType.java:593)
    	at jadx.core.dex.attributes.nodes.ClassTypeVarsAttr.getTypeVarsMapFor(ClassTypeVarsAttr.java:35)
    	at jadx.core.dex.nodes.utils.TypeUtils.replaceClassGenerics(TypeUtils.java:177)
    	at jadx.core.dex.visitors.typeinference.FixTypesVisitor.insertExplicitUseCast(FixTypesVisitor.java:397)
    	at jadx.core.dex.visitors.typeinference.FixTypesVisitor.tryFieldTypeWithNewCasts(FixTypesVisitor.java:359)
    	at jadx.core.dex.visitors.typeinference.FixTypesVisitor.applyFieldType(FixTypesVisitor.java:309)
    	at jadx.core.dex.visitors.typeinference.FixTypesVisitor.visit(FixTypesVisitor.java:94)
     */
    @hs0
    public boolean set(@x17 V v) {
        if (v == null) {
            v = (V) NULL;
        }
        if (!ATOMIC_HELPER.b(this, null, v)) {
            return false;
        }
        c(this, false);
        return true;
    }

    @hs0
    public boolean setException(Throwable th) {
        th.getClass();
        if (!ATOMIC_HELPER.b(this, null, new d(th))) {
            return false;
        }
        c(this, false);
        return true;
    }

    /* JADX WARN: Removed duplicated region for block: B:23:0x0048  */
    @hs0
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public boolean setFuture(zb5<? extends V> zb5Var) {
        d dVar;
        zb5Var.getClass();
        Object obj = this.value;
        if (obj != null) {
            if (obj instanceof c) {
                zb5Var.cancel(((c) obj).a);
            }
        } else if (zb5Var.isDone()) {
            if (ATOMIC_HELPER.b(this, null, f(zb5Var))) {
                c(this, false);
                return true;
            }
        } else {
            g gVar = new g(this, zb5Var);
            if (ATOMIC_HELPER.b(this, null, gVar)) {
                try {
                    zb5Var.addListener(gVar, za2.a);
                    return true;
                } catch (Throwable th) {
                    try {
                        dVar = new d(th);
                    } catch (Error | Exception unused) {
                        dVar = d.b;
                    }
                    ATOMIC_HELPER.b(this, gVar, dVar);
                    return true;
                }
            }
            obj = this.value;
            if (obj instanceof c) {
            }
        }
        return false;
    }

    /* JADX WARN: Removed duplicated region for block: B:34:0x00a4  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public String toString() {
        String strPendingToString;
        StringBuilder sb = new StringBuilder();
        if (getClass().getName().startsWith("com.google.common.util.concurrent.")) {
            sb.append(getClass().getSimpleName());
        } else {
            sb.append(getClass().getName());
        }
        sb.append('@');
        sb.append(Integer.toHexString(System.identityHashCode(this)));
        sb.append("[status=");
        if (isCancelled()) {
            sb.append("CANCELLED");
        } else if (isDone()) {
            a(sb);
        } else {
            int length = sb.length();
            sb.append("PENDING");
            Object obj = this.value;
            if (obj instanceof g) {
                sb.append(", setFuture=[");
                zb5 zb5Var = ((g) obj).b;
                try {
                    if (zb5Var == this) {
                        sb.append("this future");
                    } else {
                        sb.append(zb5Var);
                    }
                } catch (Exception e2) {
                    e = e2;
                    sb.append("Exception thrown from implementation: ");
                    sb.append(e.getClass());
                } catch (StackOverflowError e3) {
                    e = e3;
                    sb.append("Exception thrown from implementation: ");
                    sb.append(e.getClass());
                }
                sb.append("]");
            } else {
                try {
                    strPendingToString = pendingToString();
                } catch (Exception | StackOverflowError e4) {
                    strPendingToString = "Exception thrown from implementation: " + e4.getClass();
                }
                if (strPendingToString != null) {
                    if (strPendingToString.isEmpty()) {
                        strPendingToString = null;
                    }
                    if (strPendingToString != null) {
                        sb.append(", info=[");
                        sb.append(strPendingToString);
                        sb.append("]");
                    }
                }
            }
            if (isDone()) {
                sb.delete(length, sb.length());
                a(sb);
            }
        }
        sb.append("]");
        return sb.toString();
    }

    @Override // defpackage.jq4
    @ez0
    public final Throwable tryInternalFastPathGetFailure() {
        if (!(this instanceof i)) {
            return null;
        }
        Object obj = this.value;
        if (obj instanceof d) {
            return ((d) obj).a;
        }
        return null;
    }

    public final boolean wasInterrupted() {
        Object obj = this.value;
        return (obj instanceof c) && ((c) obj).a;
    }

    public static final class e {
        public static final e d = new e();
        public final Runnable a;
        public final Executor b;
        public e c;

        public e(Runnable runnable, Executor executor) {
            this.a = runnable;
            this.b = executor;
        }

        public e() {
            this.a = null;
            this.b = null;
        }
    }

    @Override // java.util.concurrent.Future
    @hs0
    @x17
    public V get() throws ExecutionException, InterruptedException {
        Object obj;
        l lVar = l.c;
        if (!Thread.interrupted()) {
            Object obj2 = this.value;
            if ((obj2 != null) & (!(obj2 instanceof g))) {
                return (V) e(obj2);
            }
            l lVar2 = this.waiters;
            if (lVar2 != lVar) {
                l lVar3 = new l();
                do {
                    ATOMIC_HELPER.f(lVar3, lVar2);
                    if (ATOMIC_HELPER.c(this, lVar2, lVar3)) {
                        do {
                            LockSupport.park(this);
                            if (!Thread.interrupted()) {
                                obj = this.value;
                            } else {
                                g(lVar3);
                                throw new InterruptedException();
                            }
                        } while (!((obj != null) & (!(obj instanceof g))));
                        return (V) e(obj);
                    }
                    lVar2 = this.waiters;
                } while (lVar2 != lVar);
            }
            Object obj3 = this.value;
            Objects.requireNonNull(obj3);
            return (V) e(obj3);
        }
        throw new InterruptedException();
    }
}