Initial import of ADIF API reverse-engineering toolkit

apk_decompiled/sources/h3/a.java

@@ -0,0 +1,32 @@
+package h3;
+
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes3.dex */
+public abstract class a {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final String f6778a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final boolean f6779b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public c f6780c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public long f6781d;
+
+    public a(String name, boolean z3) {
+        Intrinsics.checkNotNullParameter(name, "name");
+        this.f6778a = name;
+        this.f6779b = z3;
+        this.f6781d = -1L;
+    }
+
+    public abstract long a();
+
+    public final String toString() {
+        return this.f6778a;
+    }
+}

apk_decompiled/sources/h3/b.java

@@ -0,0 +1,106 @@
+package h3;
+
+import i3.m;
+import java.io.IOException;
+import java.net.Socket;
+import java.util.Iterator;
+import kotlin.Unit;
+import kotlin.jvm.internal.Intrinsics;
+import l3.l;
+import l3.q;
+
+/* loaded from: classes3.dex */
+public final class b extends a {
+
+    /* renamed from: e, reason: collision with root package name */
+    public final /* synthetic */ int f6782e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public final /* synthetic */ Object f6783f;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public /* synthetic */ b(Object obj, int i, String str) {
+        super(str, true);
+        this.f6782e = i;
+        this.f6783f = obj;
+    }
+
+    @Override // h3.a
+    public final long a() {
+        int i = 0;
+        switch (this.f6782e) {
+            case 0:
+                ((l) this.f6783f).invoke();
+                return -1L;
+            case 1:
+                m mVar = (m) this.f6783f;
+                long nanoTime = System.nanoTime();
+                Iterator it = mVar.f6889d.iterator();
+                long j4 = Long.MIN_VALUE;
+                i3.l lVar = null;
+                int i4 = 0;
+                while (it.hasNext()) {
+                    i3.l connection = (i3.l) it.next();
+                    Intrinsics.checkNotNullExpressionValue(connection, "connection");
+                    synchronized (connection) {
+                        if (mVar.b(connection, nanoTime) > 0) {
+                            i4++;
+                        } else {
+                            i++;
+                            long j5 = nanoTime - connection.f6885q;
+                            if (j5 > j4) {
+                                lVar = connection;
+                                j4 = j5;
+                            }
+                            Unit unit = Unit.INSTANCE;
+                        }
+                    }
+                }
+                long j6 = mVar.f6886a;
+                if (j4 < j6 && i <= 5) {
+                    if (i > 0) {
+                        return j6 - j4;
+                    }
+                    if (i4 > 0) {
+                        return j6;
+                    }
+                    return -1L;
+                }
+                Intrinsics.checkNotNull(lVar);
+                synchronized (lVar) {
+                    if (!lVar.p.isEmpty()) {
+                        return 0L;
+                    }
+                    if (lVar.f6885q + j4 != nanoTime) {
+                        return 0L;
+                    }
+                    lVar.f6879j = true;
+                    mVar.f6889d.remove(lVar);
+                    Socket socket = lVar.f6875d;
+                    Intrinsics.checkNotNull(socket);
+                    f3.c.d(socket);
+                    if (!mVar.f6889d.isEmpty()) {
+                        return 0L;
+                    }
+                    mVar.f6887b.a();
+                    return 0L;
+                }
+            default:
+                q qVar = (q) this.f6783f;
+                qVar.getClass();
+                try {
+                    qVar.f7448w.Y(2, 0, false);
+                } catch (IOException e4) {
+                    qVar.e(e4);
+                }
+                return -1L;
+        }
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public b(m mVar, String str) {
+        super(str, true);
+        this.f6782e = 1;
+        this.f6783f = mVar;
+    }
+}

apk_decompiled/sources/h3/c.java

@@ -0,0 +1,169 @@
+package h3;
+
+import f0.C0338b;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.logging.Level;
+import kotlin.Unit;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes3.dex */
+public final class c {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final e f6784a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final String f6785b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public boolean f6786c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public a f6787d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final ArrayList f6788e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public boolean f6789f;
+
+    public c(e taskRunner, String name) {
+        Intrinsics.checkNotNullParameter(taskRunner, "taskRunner");
+        Intrinsics.checkNotNullParameter(name, "name");
+        this.f6784a = taskRunner;
+        this.f6785b = name;
+        this.f6788e = new ArrayList();
+    }
+
+    public final void a() {
+        byte[] bArr = f3.c.f6469a;
+        synchronized (this.f6784a) {
+            try {
+                if (b()) {
+                    this.f6784a.d(this);
+                }
+                Unit unit = Unit.INSTANCE;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public final boolean b() {
+        a aVar = this.f6787d;
+        if (aVar != null) {
+            Intrinsics.checkNotNull(aVar);
+            if (aVar.f6779b) {
+                this.f6789f = true;
+            }
+        }
+        ArrayList arrayList = this.f6788e;
+        boolean z3 = false;
+        for (int size = arrayList.size() - 1; -1 < size; size--) {
+            if (((a) arrayList.get(size)).f6779b) {
+                a aVar2 = (a) arrayList.get(size);
+                C0338b c0338b = e.h;
+                if (e.f6792j.isLoggable(Level.FINE)) {
+                    m3.d.b(aVar2, this, "canceled");
+                }
+                arrayList.remove(size);
+                z3 = true;
+            }
+        }
+        return z3;
+    }
+
+    public final void c(a task, long j4) {
+        Intrinsics.checkNotNullParameter(task, "task");
+        synchronized (this.f6784a) {
+            if (!this.f6786c) {
+                if (d(task, j4, false)) {
+                    this.f6784a.d(this);
+                }
+                Unit unit = Unit.INSTANCE;
+            } else if (task.f6779b) {
+                C0338b c0338b = e.h;
+                if (e.f6792j.isLoggable(Level.FINE)) {
+                    m3.d.b(task, this, "schedule canceled (queue is shutdown)");
+                }
+            } else {
+                C0338b c0338b2 = e.h;
+                if (e.f6792j.isLoggable(Level.FINE)) {
+                    m3.d.b(task, this, "schedule failed (queue is shutdown)");
+                }
+                throw new RejectedExecutionException();
+            }
+        }
+    }
+
+    public final boolean d(a task, long j4, boolean z3) {
+        Intrinsics.checkNotNullParameter(task, "task");
+        task.getClass();
+        Intrinsics.checkNotNullParameter(this, "queue");
+        c cVar = task.f6780c;
+        if (cVar != this) {
+            if (cVar != null) {
+                throw new IllegalStateException("task is in multiple queues");
+            }
+            task.f6780c = this;
+        }
+        d dVar = this.f6784a.f6793a;
+        long nanoTime = System.nanoTime();
+        long j5 = nanoTime + j4;
+        ArrayList arrayList = this.f6788e;
+        int indexOf = arrayList.indexOf(task);
+        if (indexOf != -1) {
+            if (task.f6781d <= j5) {
+                C0338b c0338b = e.h;
+                if (e.f6792j.isLoggable(Level.FINE)) {
+                    m3.d.b(task, this, "already scheduled");
+                    return false;
+                }
+            }
+            arrayList.remove(indexOf);
+        }
+        task.f6781d = j5;
+        C0338b c0338b2 = e.h;
+        if (e.f6792j.isLoggable(Level.FINE)) {
+            m3.d.b(task, this, z3 ? "run again after ".concat(m3.d.q(j5 - nanoTime)) : "scheduled after ".concat(m3.d.q(j5 - nanoTime)));
+        }
+        Iterator it = arrayList.iterator();
+        int i = 0;
+        while (true) {
+            if (!it.hasNext()) {
+                i = -1;
+                break;
+            }
+            if (((a) it.next()).f6781d - nanoTime > j4) {
+                break;
+            }
+            i++;
+        }
+        if (i == -1) {
+            i = arrayList.size();
+        }
+        arrayList.add(i, task);
+        return i == 0;
+    }
+
+    public final void e() {
+        byte[] bArr = f3.c.f6469a;
+        synchronized (this.f6784a) {
+            try {
+                this.f6786c = true;
+                if (b()) {
+                    this.f6784a.d(this);
+                }
+                Unit unit = Unit.INSTANCE;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public final String toString() {
+        return this.f6785b;
+    }
+}

apk_decompiled/sources/h3/d.java

@@ -0,0 +1,319 @@
+package h3;
+
+import G2.f;
+import I2.k;
+import O.D0;
+import O.InterfaceC0080v;
+import O.X;
+import P.t;
+import a.AbstractC0106b;
+import android.os.SystemClock;
+import android.util.Log;
+import android.view.MenuItem;
+import android.view.View;
+import androidx.appcompat.widget.ActionMenuView;
+import androidx.appcompat.widget.Toolbar;
+import androidx.profileinstaller.ProfileInstallReceiver;
+import com.adif.elcanomovil.R;
+import com.adif.elcanomovil.main.BottomNavFragment;
+import com.google.android.gms.maps.model.BitmapDescriptorFactory;
+import com.google.android.material.behavior.SwipeDismissBehavior;
+import com.google.android.material.bottomnavigation.BottomNavigationView;
+import com.google.android.material.bottomsheet.BottomSheetBehavior;
+import g.M;
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.WeakHashMap;
+import java.util.concurrent.SynchronousQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import kotlin.jvm.internal.Intrinsics;
+import l.C0428f;
+import l.InterfaceC0433k;
+import l.RunnableC0427e;
+import l.SubMenuC0422E;
+import l.ViewOnKeyListenerC0429g;
+import l.m;
+import l.o;
+import l.x;
+import m.C0472l;
+import m.InterfaceC0478o;
+import m.InterfaceC0498y0;
+import m.O0;
+import m.S0;
+import o0.AbstractC0544v;
+import o0.C0525b;
+import o0.E;
+import o0.H;
+import o0.K;
+import p2.InterfaceC0552a;
+import s0.InterfaceC0584c;
+import z2.InterfaceC0679i;
+
+/* loaded from: classes3.dex */
+public final class d implements InterfaceC0498y0, t, x, InterfaceC0433k, InterfaceC0080v, InterfaceC0552a, InterfaceC0584c {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ int f6790a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final Object f6791b;
+
+    public /* synthetic */ d(Object obj, int i) {
+        this.f6790a = i;
+        this.f6791b = obj;
+    }
+
+    private final void j(m mVar) {
+    }
+
+    @Override // s0.InterfaceC0584c
+    public void a(int i, Serializable serializable) {
+        String str;
+        switch (i) {
+            case 1:
+                str = "RESULT_INSTALL_SUCCESS";
+                break;
+            case 2:
+                str = "RESULT_ALREADY_INSTALLED";
+                break;
+            case 3:
+                str = "RESULT_UNSUPPORTED_ART_VERSION";
+                break;
+            case 4:
+                str = "RESULT_NOT_WRITABLE";
+                break;
+            case 5:
+                str = "RESULT_DESIRED_FORMAT_UNSUPPORTED";
+                break;
+            case 6:
+                str = "RESULT_BASELINE_PROFILE_NOT_FOUND";
+                break;
+            case 7:
+                str = "RESULT_IO_EXCEPTION";
+                break;
+            case 8:
+                str = "RESULT_PARSE_EXCEPTION";
+                break;
+            case 9:
+            default:
+                str = "";
+                break;
+            case 10:
+                str = "RESULT_INSTALL_SKIP_FILE_SUCCESS";
+                break;
+            case 11:
+                str = "RESULT_DELETE_SKIP_FILE_SUCCESS";
+                break;
+        }
+        if (i == 6 || i == 7 || i == 8) {
+            Log.e("ProfileInstaller", str, (Throwable) serializable);
+        } else {
+            Log.d("ProfileInstaller", str);
+        }
+        ((ProfileInstallReceiver) this.f6791b).setResultCode(i);
+    }
+
+    @Override // l.x
+    public void b(m mVar, boolean z3) {
+        if (mVar instanceof SubMenuC0422E) {
+            ((SubMenuC0422E) mVar).f7179z.k().c(false);
+        }
+        x xVar = ((C0472l) this.f6791b).f7680e;
+        if (xVar != null) {
+            xVar.b(mVar, z3);
+        }
+    }
+
+    @Override // l.InterfaceC0433k
+    public boolean c(m mVar, MenuItem item) {
+        boolean onMenuItemSelected;
+        int i;
+        int i4;
+        int i5;
+        int i6;
+        int i7;
+        boolean z3;
+        Object obj = this.f6791b;
+        switch (this.f6790a) {
+            case 6:
+                InterfaceC0478o interfaceC0478o = ((ActionMenuView) obj).f2412A;
+                if (interfaceC0478o == null) {
+                    return false;
+                }
+                Toolbar toolbar = ((O0) interfaceC0478o).f7602a;
+                if (toolbar.f2467G.a(item)) {
+                    onMenuItemSelected = true;
+                } else {
+                    S0 s02 = toolbar.f2469I;
+                    onMenuItemSelected = s02 != null ? ((M) s02).f6555a.f6557b.f6671a.onMenuItemSelected(0, item) : false;
+                }
+                return onMenuItemSelected;
+            default:
+                BottomNavigationView bottomNavigationView = (BottomNavigationView) obj;
+                if (bottomNavigationView.f9093f == null || item.getItemId() != bottomNavigationView.getSelectedItemId()) {
+                    InterfaceC0679i interfaceC0679i = bottomNavigationView.f9092e;
+                    if (interfaceC0679i == null) {
+                        return false;
+                    }
+                    AbstractC0544v navController = (AbstractC0544v) ((k) interfaceC0679i).f823b;
+                    Intrinsics.checkNotNullParameter(navController, "$navController");
+                    Intrinsics.checkNotNullParameter(item, "item");
+                    Intrinsics.checkNotNullParameter(item, "item");
+                    Intrinsics.checkNotNullParameter(navController, "navController");
+                    E g4 = navController.g();
+                    Intrinsics.checkNotNull(g4);
+                    H h = g4.f7921b;
+                    Intrinsics.checkNotNull(h);
+                    if (h.j(item.getItemId(), true) instanceof C0525b) {
+                        i = R.anim.nav_default_enter_anim;
+                        i4 = R.anim.nav_default_exit_anim;
+                        i5 = R.anim.nav_default_pop_enter_anim;
+                        i6 = R.anim.nav_default_pop_exit_anim;
+                    } else {
+                        i = R.animator.nav_default_enter_anim;
+                        i4 = R.animator.nav_default_exit_anim;
+                        i5 = R.animator.nav_default_pop_enter_anim;
+                        i6 = R.animator.nav_default_pop_exit_anim;
+                    }
+                    int i8 = i;
+                    int i9 = i4;
+                    int i10 = i5;
+                    int i11 = i6;
+                    if ((item.getOrder() & 196608) == 0) {
+                        int i12 = H.f7930n;
+                        i7 = AbstractC0106b.h(navController.i()).h;
+                        z3 = true;
+                    } else {
+                        i7 = -1;
+                        z3 = false;
+                    }
+                    try {
+                        navController.m(item.getItemId(), null, new K(true, true, i7, false, z3, i8, i9, i10, i11));
+                        E g5 = navController.g();
+                        if (g5 != null) {
+                            if (AbstractC0106b.u(g5, item.getItemId())) {
+                                return false;
+                            }
+                        }
+                    } catch (IllegalArgumentException unused) {
+                    }
+                } else {
+                    BottomNavFragment.f((BottomNavFragment) ((k) bottomNavigationView.f9093f).f823b, item);
+                }
+                return true;
+        }
+    }
+
+    @Override // P.t
+    public boolean d(View view) {
+        SwipeDismissBehavior swipeDismissBehavior = (SwipeDismissBehavior) this.f6791b;
+        if (!swipeDismissBehavior.v(view)) {
+            return false;
+        }
+        WeakHashMap weakHashMap = X.f1226a;
+        boolean z3 = view.getLayoutDirection() == 1;
+        int i = swipeDismissBehavior.f5534e;
+        view.offsetLeftAndRight((!(i == 0 && z3) && (i != 1 || z3)) ? view.getWidth() : -view.getWidth());
+        view.setAlpha(BitmapDescriptorFactory.HUE_RED);
+        f fVar = swipeDismissBehavior.f5531b;
+        if (fVar != null) {
+            fVar.a(view);
+        }
+        return true;
+    }
+
+    @Override // m.InterfaceC0498y0
+    public void e(m mVar, o oVar) {
+        ((ViewOnKeyListenerC0429g) this.f6791b).f7208f.removeCallbacksAndMessages(mVar);
+    }
+
+    @Override // l.x
+    public boolean f(m mVar) {
+        C0472l c0472l = (C0472l) this.f6791b;
+        if (mVar == c0472l.f7678c) {
+            return false;
+        }
+        c0472l.f7697y = ((SubMenuC0422E) mVar).f7178A.f7268a;
+        x xVar = c0472l.f7680e;
+        if (xVar != null) {
+            return xVar.f(mVar);
+        }
+        return false;
+    }
+
+    @Override // O.InterfaceC0080v
+    public D0 g(View view, D0 d02) {
+        o2.e eVar = (o2.e) this.f6791b;
+        o2.d dVar = eVar.f8097m;
+        if (dVar != null) {
+            eVar.f8092f.f5558W.remove(dVar);
+        }
+        o2.d dVar2 = new o2.d(eVar.i, d02);
+        eVar.f8097m = dVar2;
+        dVar2.b(eVar.getWindow());
+        BottomSheetBehavior bottomSheetBehavior = eVar.f8092f;
+        o2.d dVar3 = eVar.f8097m;
+        ArrayList arrayList = bottomSheetBehavior.f5558W;
+        if (!arrayList.contains(dVar3)) {
+            arrayList.add(dVar3);
+        }
+        return d02;
+    }
+
+    @Override // s0.InterfaceC0584c
+    public void h() {
+        Log.d("ProfileInstaller", "DIAGNOSTIC_PROFILE_IS_COMPRESSED");
+    }
+
+    @Override // l.InterfaceC0433k
+    public void i(m mVar) {
+        switch (this.f6790a) {
+            case 6:
+                InterfaceC0433k interfaceC0433k = ((ActionMenuView) this.f6791b).f2418v;
+                if (interfaceC0433k != null) {
+                    interfaceC0433k.i(mVar);
+                    return;
+                }
+                return;
+            default:
+                return;
+        }
+    }
+
+    @Override // m.InterfaceC0498y0
+    public void m(m mVar, o oVar) {
+        ViewOnKeyListenerC0429g viewOnKeyListenerC0429g = (ViewOnKeyListenerC0429g) this.f6791b;
+        viewOnKeyListenerC0429g.f7208f.removeCallbacksAndMessages(null);
+        ArrayList arrayList = viewOnKeyListenerC0429g.h;
+        int size = arrayList.size();
+        int i = 0;
+        while (true) {
+            if (i >= size) {
+                i = -1;
+                break;
+            } else if (mVar == ((C0428f) arrayList.get(i)).f7202b) {
+                break;
+            } else {
+                i++;
+            }
+        }
+        if (i == -1) {
+            return;
+        }
+        int i4 = i + 1;
+        viewOnKeyListenerC0429g.f7208f.postAtTime(new RunnableC0427e(this, i4 < arrayList.size() ? (C0428f) arrayList.get(i4) : null, oVar, mVar), mVar, SystemClock.uptimeMillis() + 200);
+    }
+
+    public d() {
+        this.f6790a = 1;
+        this.f6791b = new LinkedHashSet();
+    }
+
+    public d(f3.b threadFactory) {
+        this.f6790a = 0;
+        Intrinsics.checkNotNullParameter(threadFactory, "threadFactory");
+        this.f6791b = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue(), threadFactory);
+    }
+}

apk_decompiled/sources/h3/e.java

@@ -0,0 +1,227 @@
+package h3;
+
+import f0.C0338b;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.logging.Logger;
+import kotlin.Unit;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.LongCompanionObject;
+
+/* loaded from: classes3.dex */
+public final class e {
+    public static final C0338b h = new C0338b(5);
+    public static final e i;
+
+    /* renamed from: j, reason: collision with root package name */
+    public static final Logger f6792j;
+
+    /* renamed from: a, reason: collision with root package name */
+    public final d f6793a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public int f6794b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public boolean f6795c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public long f6796d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final ArrayList f6797e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public final ArrayList f6798f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public final F0.c f6799g;
+
+    static {
+        String name = f3.c.f6475g + " TaskRunner";
+        Intrinsics.checkNotNullParameter(name, "name");
+        i = new e(new d(new f3.b(name, true)));
+        Logger logger = Logger.getLogger(e.class.getName());
+        Intrinsics.checkNotNullExpressionValue(logger, "getLogger(TaskRunner::class.java.name)");
+        f6792j = logger;
+    }
+
+    public e(d backend) {
+        Intrinsics.checkNotNullParameter(backend, "backend");
+        this.f6793a = backend;
+        this.f6794b = 10000;
+        this.f6797e = new ArrayList();
+        this.f6798f = new ArrayList();
+        this.f6799g = new F0.c(this, 8);
+    }
+
+    public static final void a(e eVar, a aVar) {
+        eVar.getClass();
+        byte[] bArr = f3.c.f6469a;
+        Thread currentThread = Thread.currentThread();
+        String name = currentThread.getName();
+        currentThread.setName(aVar.f6778a);
+        try {
+            long a2 = aVar.a();
+            synchronized (eVar) {
+                eVar.b(aVar, a2);
+                Unit unit = Unit.INSTANCE;
+            }
+            currentThread.setName(name);
+        } catch (Throwable th) {
+            synchronized (eVar) {
+                eVar.b(aVar, -1L);
+                Unit unit2 = Unit.INSTANCE;
+                currentThread.setName(name);
+                throw th;
+            }
+        }
+    }
+
+    public final void b(a aVar, long j4) {
+        byte[] bArr = f3.c.f6469a;
+        c cVar = aVar.f6780c;
+        Intrinsics.checkNotNull(cVar);
+        if (cVar.f6787d != aVar) {
+            throw new IllegalStateException("Check failed.");
+        }
+        boolean z3 = cVar.f6789f;
+        cVar.f6789f = false;
+        cVar.f6787d = null;
+        this.f6797e.remove(cVar);
+        if (j4 != -1 && !z3 && !cVar.f6786c) {
+            cVar.d(aVar, j4, true);
+        }
+        if (cVar.f6788e.isEmpty()) {
+            return;
+        }
+        this.f6798f.add(cVar);
+    }
+
+    public final a c() {
+        long j4;
+        a aVar;
+        boolean z3;
+        byte[] bArr = f3.c.f6469a;
+        while (true) {
+            ArrayList arrayList = this.f6798f;
+            if (arrayList.isEmpty()) {
+                return null;
+            }
+            d dVar = this.f6793a;
+            long nanoTime = System.nanoTime();
+            Iterator it = arrayList.iterator();
+            long j5 = LongCompanionObject.MAX_VALUE;
+            a aVar2 = null;
+            while (true) {
+                if (!it.hasNext()) {
+                    j4 = nanoTime;
+                    aVar = null;
+                    z3 = false;
+                    break;
+                }
+                a aVar3 = (a) ((c) it.next()).f6788e.get(0);
+                j4 = nanoTime;
+                aVar = null;
+                long max = Math.max(0L, aVar3.f6781d - j4);
+                if (max > 0) {
+                    j5 = Math.min(max, j5);
+                } else {
+                    if (aVar2 != null) {
+                        z3 = true;
+                        break;
+                    }
+                    aVar2 = aVar3;
+                }
+                nanoTime = j4;
+            }
+            ArrayList arrayList2 = this.f6797e;
+            if (aVar2 != null) {
+                byte[] bArr2 = f3.c.f6469a;
+                aVar2.f6781d = -1L;
+                c cVar = aVar2.f6780c;
+                Intrinsics.checkNotNull(cVar);
+                cVar.f6788e.remove(aVar2);
+                arrayList.remove(cVar);
+                cVar.f6787d = aVar2;
+                arrayList2.add(cVar);
+                if (z3 || (!this.f6795c && !arrayList.isEmpty())) {
+                    F0.c runnable = this.f6799g;
+                    Intrinsics.checkNotNullParameter(runnable, "runnable");
+                    ((ThreadPoolExecutor) dVar.f6791b).execute(runnable);
+                }
+                return aVar2;
+            }
+            if (this.f6795c) {
+                if (j5 >= this.f6796d - j4) {
+                    return aVar;
+                }
+                Intrinsics.checkNotNullParameter(this, "taskRunner");
+                notify();
+                return aVar;
+            }
+            this.f6795c = true;
+            this.f6796d = j4 + j5;
+            try {
+                try {
+                    Intrinsics.checkNotNullParameter(this, "taskRunner");
+                    long j6 = j5 / 1000000;
+                    long j7 = j5 - (1000000 * j6);
+                    if (j6 > 0 || j5 > 0) {
+                        wait(j6, (int) j7);
+                    }
+                } catch (InterruptedException unused) {
+                    for (int size = arrayList2.size() - 1; -1 < size; size--) {
+                        ((c) arrayList2.get(size)).b();
+                    }
+                    for (int size2 = arrayList.size() - 1; -1 < size2; size2--) {
+                        c cVar2 = (c) arrayList.get(size2);
+                        cVar2.b();
+                        if (cVar2.f6788e.isEmpty()) {
+                            arrayList.remove(size2);
+                        }
+                    }
+                }
+            } finally {
+                this.f6795c = false;
+            }
+        }
+    }
+
+    public final void d(c taskQueue) {
+        Intrinsics.checkNotNullParameter(taskQueue, "taskQueue");
+        byte[] bArr = f3.c.f6469a;
+        if (taskQueue.f6787d == null) {
+            boolean isEmpty = taskQueue.f6788e.isEmpty();
+            ArrayList arrayList = this.f6798f;
+            if (isEmpty) {
+                arrayList.remove(taskQueue);
+            } else {
+                Intrinsics.checkNotNullParameter(arrayList, "<this>");
+                if (!arrayList.contains(taskQueue)) {
+                    arrayList.add(taskQueue);
+                }
+            }
+        }
+        boolean z3 = this.f6795c;
+        d dVar = this.f6793a;
+        if (z3) {
+            Intrinsics.checkNotNullParameter(this, "taskRunner");
+            notify();
+        } else {
+            F0.c runnable = this.f6799g;
+            Intrinsics.checkNotNullParameter(runnable, "runnable");
+            ((ThreadPoolExecutor) dVar.f6791b).execute(runnable);
+        }
+    }
+
+    public final c e() {
+        int i4;
+        synchronized (this) {
+            i4 = this.f6794b;
+            this.f6794b = i4 + 1;
+        }
+        return new c(this, com.google.android.gms.measurement.internal.a.l(i4, "Q"));
+    }
+}