package p025.p026.p030;

import java.io.Closeable;
import java.util.ArrayList;
import java.util.concurrent.Executor;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
import java.util.concurrent.atomic.AtomicLongFieldUpdater;
import java.util.concurrent.atomic.AtomicReferenceArray;
import java.util.concurrent.locks.LockSupport;
import kotlin.jvm.internal.DefaultConstructorMarker;
import p025.p026.p027.C1296;
import p138.p139.p143.p144.C2803;
import p138.p176.p177.p242.p246.p251.C4303;
import p402.InterfaceC6540;
import p402.p411.p413.C6635;
import p402.p416.AbstractC6656;

/* JADX INFO: renamed from: އ.֏.ၸ.֏, reason: contains not printable characters */
/* JADX INFO: loaded from: classes.dex */
@InterfaceC6540
public final class ExecutorC1420 implements Executor, Closeable {

    /* JADX INFO: renamed from: ފ, reason: contains not printable characters */
    public static final AtomicLongFieldUpdater f4580;

    /* JADX INFO: renamed from: ދ, reason: contains not printable characters */
    public static final AtomicLongFieldUpdater f4581;

    /* JADX INFO: renamed from: ތ, reason: contains not printable characters */
    public static final AtomicIntegerFieldUpdater f4582;

    /* JADX INFO: renamed from: ލ, reason: contains not printable characters */
    public static final C1296 f4583;
    public volatile int _isTerminated;
    public volatile long controlState;
    public volatile long parkedWorkersStack;

    /* JADX INFO: renamed from: ރ, reason: contains not printable characters */
    public final C1426 f4584;

    /* JADX INFO: renamed from: ބ, reason: contains not printable characters */
    public final C1426 f4585;

    /* JADX INFO: renamed from: ޅ, reason: contains not printable characters */
    public final AtomicReferenceArray<C1422> f4586;

    /* JADX INFO: renamed from: ކ, reason: contains not printable characters */
    public final int f4587;

    /* JADX INFO: renamed from: އ, reason: contains not printable characters */
    public final int f4588;

    /* JADX INFO: renamed from: ވ, reason: contains not printable characters */
    public final long f4589;

    /* JADX INFO: renamed from: މ, reason: contains not printable characters */
    public final String f4590;

    /* JADX INFO: renamed from: އ.֏.ၸ.֏$֏, reason: contains not printable characters */
    public static final class C1421 {
        public C1421() {
        }

        public /* synthetic */ C1421(DefaultConstructorMarker defaultConstructorMarker) {
        }
    }

    /* JADX INFO: renamed from: އ.֏.ၸ.֏$ؠ, reason: contains not printable characters */
    public final class C1422 extends Thread {

        /* JADX INFO: renamed from: ފ, reason: contains not printable characters */
        public static final AtomicIntegerFieldUpdater f4591 = AtomicIntegerFieldUpdater.newUpdater(C1422.class, "workerCtl");
        public volatile int indexInArray;
        public volatile Object nextParkedWorker;
        public volatile int workerCtl;

        /* JADX INFO: renamed from: ރ, reason: contains not printable characters */
        public final C1435 f4592;

        /* JADX INFO: renamed from: ބ, reason: contains not printable characters */
        public EnumC1423 f4593;

        /* JADX INFO: renamed from: ޅ, reason: contains not printable characters */
        public long f4594;

        /* JADX INFO: renamed from: ކ, reason: contains not printable characters */
        public long f4595;

        /* JADX INFO: renamed from: އ, reason: contains not printable characters */
        public int f4596;

        /* JADX INFO: renamed from: ވ, reason: contains not printable characters */
        public boolean f4597;

        public C1422(int i) {
            setDaemon(true);
            this.f4592 = new C1435();
            this.f4593 = EnumC1423.DORMANT;
            this.workerCtl = 0;
            this.nextParkedWorker = ExecutorC1420.f4583;
            this.f4596 = AbstractC6656.f19409.mo9837();
            m2769(i);
        }

        /* JADX WARN: Code restructure failed: missing block: B:60:0x0100, code lost:
        
            m2766(p025.p026.p030.ExecutorC1420.EnumC1423.f4603);
         */
        /* JADX WARN: Code restructure failed: missing block: B:61:0x0105, code lost:
        
            return;
         */
        @Override // java.lang.Thread, java.lang.Runnable
        /*
            Code decompiled incorrectly, please refer to instructions dump.
        */
        public void run() {
            long j;
            int i;
            loop0: while (true) {
                boolean z = false;
                while (ExecutorC1420.this._isTerminated == 0 && this.f4593 != EnumC1423.TERMINATED) {
                    AbstractRunnableC1430 abstractRunnableC1430M2765 = m2765(this.f4597);
                    if (abstractRunnableC1430M2765 != null) {
                        this.f4595 = 0L;
                        int iMo2772 = abstractRunnableC1430M2765.f4620.mo2772();
                        this.f4594 = 0L;
                        if (this.f4593 == EnumC1423.PARKING) {
                            this.f4593 = EnumC1423.BLOCKING;
                        }
                        if (iMo2772 != 0 && m2766(EnumC1423.BLOCKING)) {
                            ExecutorC1420.this.m2759();
                        }
                        ExecutorC1420.this.m2757(abstractRunnableC1430M2765);
                        if (iMo2772 != 0) {
                            ExecutorC1420.f4581.addAndGet(ExecutorC1420.this, -2097152L);
                            if (this.f4593 != EnumC1423.TERMINATED) {
                                this.f4593 = EnumC1423.DORMANT;
                            }
                        }
                    } else {
                        this.f4597 = false;
                        if (this.f4595 == 0) {
                            if (this.nextParkedWorker != ExecutorC1420.f4583) {
                                this.workerCtl = -1;
                                while (true) {
                                    if (!(this.nextParkedWorker != ExecutorC1420.f4583) || ExecutorC1420.this._isTerminated != 0 || this.f4593 == EnumC1423.TERMINATED) {
                                        break;
                                    }
                                    m2766(EnumC1423.PARKING);
                                    Thread.interrupted();
                                    if (this.f4594 == 0) {
                                        this.f4594 = System.nanoTime() + ExecutorC1420.this.f4589;
                                    }
                                    LockSupport.parkNanos(ExecutorC1420.this.f4589);
                                    if (System.nanoTime() - this.f4594 >= 0) {
                                        this.f4594 = 0L;
                                        m2768();
                                    }
                                }
                            } else {
                                ExecutorC1420 executorC1420 = ExecutorC1420.this;
                                if (executorC1420 == null) {
                                    throw null;
                                }
                                if (this.nextParkedWorker == ExecutorC1420.f4583) {
                                    do {
                                        j = executorC1420.parkedWorkersStack;
                                        i = this.indexInArray;
                                        this.nextParkedWorker = executorC1420.f4586.get((int) (2097151 & j));
                                    } while (!ExecutorC1420.f4580.compareAndSet(executorC1420, j, ((long) i) | ((2097152 + j) & (-2097152))));
                                }
                            }
                        } else if (z) {
                            m2766(EnumC1423.PARKING);
                            Thread.interrupted();
                            LockSupport.parkNanos(this.f4595);
                            this.f4595 = 0L;
                        } else {
                            z = true;
                        }
                    }
                }
                break loop0;
            }
        }

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public final int m2763(int i) {
            int i2 = this.f4596;
            int i3 = i2 ^ (i2 << 13);
            int i4 = i3 ^ (i3 >> 17);
            int i5 = i4 ^ (i4 << 5);
            this.f4596 = i5;
            int i6 = i - 1;
            return (i6 & i) == 0 ? i5 & i6 : (i5 & Integer.MAX_VALUE) % i;
        }

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public final AbstractRunnableC1430 m2764() {
            if (m2763(2) == 0) {
                AbstractRunnableC1430 abstractRunnableC1430M2584 = ExecutorC1420.this.f4584.m2584();
                return abstractRunnableC1430M2584 != null ? abstractRunnableC1430M2584 : ExecutorC1420.this.f4585.m2584();
            }
            AbstractRunnableC1430 abstractRunnableC1430M25842 = ExecutorC1420.this.f4585.m2584();
            return abstractRunnableC1430M25842 != null ? abstractRunnableC1430M25842 : ExecutorC1420.this.f4584.m2584();
        }

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public final AbstractRunnableC1430 m2765(boolean z) {
            boolean z2;
            AbstractRunnableC1430 abstractRunnableC1430M2584;
            AbstractRunnableC1430 abstractRunnableC1430M2764;
            AbstractRunnableC1430 abstractRunnableC1430M27642;
            boolean z3;
            if (this.f4593 == EnumC1423.CPU_ACQUIRED) {
                z2 = true;
            } else {
                ExecutorC1420 executorC1420 = ExecutorC1420.this;
                while (true) {
                    long j = executorC1420.controlState;
                    if (((int) ((9223367638808264704L & j) >> 42)) == 0) {
                        z3 = false;
                        break;
                    }
                    if (ExecutorC1420.f4581.compareAndSet(executorC1420, j, j - 4398046511104L)) {
                        z3 = true;
                        break;
                    }
                }
                if (z3) {
                    this.f4593 = EnumC1423.CPU_ACQUIRED;
                    z2 = true;
                } else {
                    z2 = false;
                }
            }
            if (!z2) {
                if (!z || (abstractRunnableC1430M2584 = this.f4592.m2778()) == null) {
                    abstractRunnableC1430M2584 = ExecutorC1420.this.f4585.m2584();
                }
                return abstractRunnableC1430M2584 != null ? abstractRunnableC1430M2584 : m2767(true);
            }
            if (z) {
                boolean z4 = m2763(ExecutorC1420.this.f4587 * 2) == 0;
                if (z4 && (abstractRunnableC1430M27642 = m2764()) != null) {
                    return abstractRunnableC1430M27642;
                }
                AbstractRunnableC1430 abstractRunnableC1430M2778 = this.f4592.m2778();
                if (abstractRunnableC1430M2778 != null) {
                    return abstractRunnableC1430M2778;
                }
                if (!z4 && (abstractRunnableC1430M2764 = m2764()) != null) {
                    return abstractRunnableC1430M2764;
                }
            } else {
                AbstractRunnableC1430 abstractRunnableC1430M27643 = m2764();
                if (abstractRunnableC1430M27643 != null) {
                    return abstractRunnableC1430M27643;
                }
            }
            return m2767(false);
        }

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public final boolean m2766(EnumC1423 enumC1423) {
            EnumC1423 enumC14232 = this.f4593;
            boolean z = enumC14232 == EnumC1423.CPU_ACQUIRED;
            if (z) {
                ExecutorC1420.f4581.addAndGet(ExecutorC1420.this, 4398046511104L);
            }
            if (enumC14232 != enumC1423) {
                this.f4593 = enumC1423;
            }
            return z;
        }

        /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
        public final AbstractRunnableC1430 m2767(boolean z) {
            long jM2774;
            int i = (int) (ExecutorC1420.this.controlState & 2097151);
            if (i < 2) {
                return null;
            }
            int iM2763 = m2763(i);
            long jMin = Long.MAX_VALUE;
            for (int i2 = 0; i2 < i; i2++) {
                iM2763++;
                if (iM2763 > i) {
                    iM2763 = 1;
                }
                C1422 c1422 = ExecutorC1420.this.f4586.get(iM2763);
                if (c1422 != null && c1422 != this) {
                    if (z) {
                        C1435 c1435 = this.f4592;
                        C1435 c14352 = c1422.f4592;
                        if (c1435 == null) {
                            throw null;
                        }
                        int i3 = c14352.producerIndex;
                        AtomicReferenceArray<AbstractRunnableC1430> atomicReferenceArray = c14352.f4631;
                        for (int i4 = c14352.consumerIndex; i4 != i3; i4++) {
                            int i5 = i4 & 127;
                            if (c14352.blockingTasksInBuffer == 0) {
                                break;
                            }
                            AbstractRunnableC1430 abstractRunnableC1430 = atomicReferenceArray.get(i5);
                            if (abstractRunnableC1430 != null) {
                                if ((abstractRunnableC1430.f4620.mo2772() == 1) && atomicReferenceArray.compareAndSet(i5, abstractRunnableC1430, null)) {
                                    C1435.f4630.decrementAndGet(c14352);
                                    c1435.m2776(abstractRunnableC1430, false);
                                    jM2774 = -1;
                                    break;
                                }
                            }
                        }
                        jM2774 = c1435.m2774(c14352, true);
                    } else {
                        C1435 c14353 = this.f4592;
                        C1435 c14354 = c1422.f4592;
                        if (c14353 == null) {
                            throw null;
                        }
                        AbstractRunnableC1430 abstractRunnableC1430M2779 = c14354.m2779();
                        if (abstractRunnableC1430M2779 != null) {
                            c14353.m2776(abstractRunnableC1430M2779, false);
                            jM2774 = -1;
                        } else {
                            jM2774 = c14353.m2774(c14354, false);
                        }
                    }
                    if (jM2774 == -1) {
                        return this.f4592.m2778();
                    }
                    if (jM2774 > 0) {
                        jMin = Math.min(jMin, jM2774);
                    }
                }
            }
            if (jMin == Long.MAX_VALUE) {
                jMin = 0;
            }
            this.f4595 = jMin;
            return null;
        }

        /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
        public final void m2768() {
            synchronized (ExecutorC1420.this.f4586) {
                if (ExecutorC1420.this._isTerminated != 0) {
                    return;
                }
                if (((int) (ExecutorC1420.this.controlState & 2097151)) <= ExecutorC1420.this.f4587) {
                    return;
                }
                if (f4591.compareAndSet(this, -1, 1)) {
                    int i = this.indexInArray;
                    m2769(0);
                    ExecutorC1420.this.m2756(this, i, 0);
                    int andDecrement = (int) (ExecutorC1420.f4581.getAndDecrement(ExecutorC1420.this) & 2097151);
                    if (andDecrement != i) {
                        C1422 c1422 = ExecutorC1420.this.f4586.get(andDecrement);
                        if (c1422 == null) {
                            C6635.m9822();
                            throw null;
                        }
                        C1422 c14222 = c1422;
                        ExecutorC1420.this.f4586.set(i, c14222);
                        c14222.m2769(i);
                        ExecutorC1420.this.m2756(c14222, andDecrement, i);
                    }
                    ExecutorC1420.this.f4586.set(andDecrement, null);
                    this.f4593 = EnumC1423.TERMINATED;
                }
            }
        }

        /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
        public final void m2769(int i) {
            StringBuilder sb = new StringBuilder();
            sb.append(ExecutorC1420.this.f4590);
            sb.append("-worker-");
            sb.append(i == 0 ? "TERMINATED" : String.valueOf(i));
            setName(sb.toString());
            this.indexInArray = i;
        }
    }

    /* JADX INFO: renamed from: އ.֏.ၸ.֏$ހ, reason: contains not printable characters */
    public enum EnumC1423 {
        CPU_ACQUIRED,
        BLOCKING,
        PARKING,
        DORMANT,
        TERMINATED
    }

    static {
        new C1421(null);
        f4583 = new C1296("NOT_IN_STACK");
        f4580 = AtomicLongFieldUpdater.newUpdater(ExecutorC1420.class, "parkedWorkersStack");
        f4581 = AtomicLongFieldUpdater.newUpdater(ExecutorC1420.class, "controlState");
        f4582 = AtomicIntegerFieldUpdater.newUpdater(ExecutorC1420.class, "_isTerminated");
    }

    public ExecutorC1420(int i, int i2, long j, String str) {
        this.f4587 = i;
        this.f4588 = i2;
        this.f4589 = j;
        this.f4590 = str;
        if (!(i >= 1)) {
            throw new IllegalArgumentException(C2803.m4882(C2803.m4889("Core pool size "), this.f4587, " should be at least 1").toString());
        }
        if (!(this.f4588 >= this.f4587)) {
            StringBuilder sbM4889 = C2803.m4889("Max pool size ");
            sbM4889.append(this.f4588);
            sbM4889.append(" should be greater than or equals to core pool size ");
            sbM4889.append(this.f4587);
            throw new IllegalArgumentException(sbM4889.toString().toString());
        }
        if (!(this.f4588 <= 2097150)) {
            throw new IllegalArgumentException(C2803.m4882(C2803.m4889("Max pool size "), this.f4588, " should not exceed maximal supported number of threads 2097150").toString());
        }
        if (!(this.f4589 > 0)) {
            throw new IllegalArgumentException(C2803.m4883(C2803.m4889("Idle worker keep alive time "), this.f4589, " must be positive").toString());
        }
        this.f4584 = new C1426();
        this.f4585 = new C1426();
        this.parkedWorkersStack = 0L;
        this.f4586 = new AtomicReferenceArray<>(this.f4588 + 1);
        this.controlState = ((long) this.f4587) << 42;
        this._isTerminated = 0;
    }

    public /* synthetic */ ExecutorC1420(int i, int i2, long j, String str, int i3, DefaultConstructorMarker defaultConstructorMarker) {
        this(i, i2, (i3 & 4) != 0 ? C1433.f4625 : j, (i3 & 8) != 0 ? "DefaultDispatcher" : str);
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static /* synthetic */ void m2751(ExecutorC1420 executorC1420, Runnable runnable, InterfaceC1431 interfaceC1431, boolean z, int i) {
        if ((i & 2) != 0) {
            interfaceC1431 = C1429.f4618;
        }
        if ((i & 4) != 0) {
            z = false;
        }
        executorC1420.m2755(runnable, interfaceC1431, z);
    }

    @Override // java.io.Closeable, java.lang.AutoCloseable
    public void close() throws InterruptedException {
        m2761(10000L);
    }

    @Override // java.util.concurrent.Executor
    public void execute(Runnable runnable) {
        m2755(runnable, (InterfaceC1431) C1429.f4618, false);
    }

    public String toString() {
        ArrayList arrayList = new ArrayList();
        int length = this.f4586.length();
        int i = 0;
        int i2 = 0;
        int i3 = 0;
        int i4 = 0;
        int i5 = 0;
        for (int i6 = 1; i6 < length; i6++) {
            C1422 c1422 = this.f4586.get(i6);
            if (c1422 != null) {
                int iM2777 = c1422.f4592.m2777();
                int iOrdinal = c1422.f4593.ordinal();
                if (iOrdinal == 0) {
                    i++;
                    arrayList.add(String.valueOf(iM2777) + "c");
                } else if (iOrdinal == 1) {
                    i2++;
                    arrayList.add(String.valueOf(iM2777) + "b");
                } else if (iOrdinal == 2) {
                    i3++;
                } else if (iOrdinal == 3) {
                    i4++;
                    if (iM2777 > 0) {
                        arrayList.add(String.valueOf(iM2777) + "d");
                    }
                } else if (iOrdinal == 4) {
                    i5++;
                }
            }
        }
        long j = this.controlState;
        return this.f4590 + '@' + C4303.m7180(this) + "[Pool Size {core = " + this.f4587 + ", max = " + this.f4588 + "}, Worker States {CPU = " + i + ", blocking = " + i2 + ", parked = " + i3 + ", dormant = " + i4 + ", terminated = " + i5 + "}, running workers queues = " + arrayList + ", global CPU queue size = " + this.f4584.m2583() + ", global blocking queue size = " + this.f4585.m2583() + ", Control State {created workers= " + ((int) (2097151 & j)) + ", blocking tasks = " + ((int) ((4398044413952L & j) >> 21)) + ", CPUs acquired = " + (this.f4587 - ((int) ((9223367638808264704L & j) >> 42))) + "}]";
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public final int m2752() {
        synchronized (this.f4586) {
            if (this._isTerminated != 0) {
                return -1;
            }
            long j = this.controlState;
            int i = (int) (j & 2097151);
            int i2 = i - ((int) ((j & 4398044413952L) >> 21));
            if (i2 < 0) {
                i2 = 0;
            }
            if (i2 >= this.f4587) {
                return 0;
            }
            if (i >= this.f4588) {
                return 0;
            }
            int i3 = ((int) (this.controlState & 2097151)) + 1;
            if (!(i3 > 0 && this.f4586.get(i3) == null)) {
                throw new IllegalArgumentException("Failed requirement.".toString());
            }
            C1422 c1422 = new C1422(i3);
            this.f4586.set(i3, c1422);
            if (!(i3 == ((int) (2097151 & f4581.incrementAndGet(this))))) {
                throw new IllegalArgumentException("Failed requirement.".toString());
            }
            c1422.start();
            return i2 + 1;
        }
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public final int m2753(C1422 c1422) {
        Object obj = c1422.nextParkedWorker;
        while (obj != f4583) {
            if (obj == null) {
                return 0;
            }
            C1422 c14222 = (C1422) obj;
            int i = c14222.indexInArray;
            if (i != 0) {
                return i;
            }
            obj = c14222.nextParkedWorker;
        }
        return -1;
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public final AbstractRunnableC1430 m2754(Runnable runnable, InterfaceC1431 interfaceC1431) {
        if (((C1428) C1433.f4626) == null) {
            throw null;
        }
        long jNanoTime = System.nanoTime();
        if (!(runnable instanceof AbstractRunnableC1430)) {
            return new C1432(runnable, jNanoTime, interfaceC1431);
        }
        AbstractRunnableC1430 abstractRunnableC1430 = (AbstractRunnableC1430) runnable;
        abstractRunnableC1430.f4619 = jNanoTime;
        abstractRunnableC1430.f4620 = interfaceC1431;
        return abstractRunnableC1430;
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public final void m2755(Runnable runnable, InterfaceC1431 interfaceC1431, boolean z) {
        AbstractRunnableC1430 abstractRunnableC1430M2776;
        AbstractRunnableC1430 abstractRunnableC1430M2754 = m2754(runnable, interfaceC1431);
        C1422 c1422M2758 = m2758();
        if (c1422M2758 == null || c1422M2758.f4593 == EnumC1423.TERMINATED || (abstractRunnableC1430M2754.f4620.mo2772() == 0 && c1422M2758.f4593 == EnumC1423.BLOCKING)) {
            abstractRunnableC1430M2776 = abstractRunnableC1430M2754;
        } else {
            c1422M2758.f4597 = true;
            abstractRunnableC1430M2776 = c1422M2758.f4592.m2776(abstractRunnableC1430M2754, z);
        }
        if (abstractRunnableC1430M2776 != null) {
            if (!(abstractRunnableC1430M2776.f4620.mo2772() == 1 ? this.f4585.m2582(abstractRunnableC1430M2776) : this.f4584.m2582(abstractRunnableC1430M2776))) {
                throw new RejectedExecutionException(C2803.m4884(new StringBuilder(), this.f4590, " was terminated"));
            }
        }
        boolean z2 = z && c1422M2758 != null;
        if (abstractRunnableC1430M2754.f4620.mo2772() == 0) {
            if (z2) {
                return;
            }
            m2759();
        } else {
            long jAddAndGet = f4581.addAndGet(this, 2097152L);
            if (z2 || m2760() || m2762(jAddAndGet)) {
                return;
            }
            m2760();
        }
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public final void m2756(C1422 c1422, int i, int i2) {
        while (true) {
            long j = this.parkedWorkersStack;
            int iM2753 = (int) (2097151 & j);
            long j2 = (2097152 + j) & (-2097152);
            if (iM2753 == i) {
                iM2753 = i2 == 0 ? m2753(c1422) : i2;
            }
            if (iM2753 >= 0 && f4580.compareAndSet(this, j, j2 | ((long) iM2753))) {
                return;
            }
        }
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public final void m2757(AbstractRunnableC1430 abstractRunnableC1430) {
        try {
            abstractRunnableC1430.run();
        } finally {
        }
    }

    /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
    public final C1422 m2758() {
        Thread threadCurrentThread = Thread.currentThread();
        if (!(threadCurrentThread instanceof C1422)) {
            threadCurrentThread = null;
        }
        C1422 c1422 = (C1422) threadCurrentThread;
        if (c1422 == null || !C6635.m9825(ExecutorC1420.this, this)) {
            return null;
        }
        return c1422;
    }

    /* JADX INFO: renamed from: ހ, reason: contains not printable characters */
    public final void m2759() {
        if (m2760() || m2762(this.controlState)) {
            return;
        }
        m2760();
    }

    /* JADX INFO: renamed from: ރ, reason: contains not printable characters */
    public final boolean m2760() {
        while (true) {
            long j = this.parkedWorkersStack;
            C1422 c1422 = this.f4586.get((int) (2097151 & j));
            if (c1422 != null) {
                long j2 = (2097152 + j) & (-2097152);
                int iM2753 = m2753(c1422);
                if (iM2753 >= 0 && f4580.compareAndSet(this, j, ((long) iM2753) | j2)) {
                    c1422.nextParkedWorker = f4583;
                }
            } else {
                c1422 = null;
            }
            if (c1422 == null) {
                return false;
            }
            if (C1422.f4591.compareAndSet(c1422, -1, 0)) {
                LockSupport.unpark(c1422);
                return true;
            }
        }
    }

    /* JADX WARN: Removed duplicated region for block: B:40:0x0076  */
    /* JADX INFO: renamed from: ކ, reason: contains not printable characters */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public final void m2761(long j) throws InterruptedException {
        int i;
        AbstractRunnableC1430 abstractRunnableC1430M2584;
        boolean z;
        if (f4582.compareAndSet(this, 0, 1)) {
            C1422 c1422M2758 = m2758();
            synchronized (this.f4586) {
                i = (int) (this.controlState & 2097151);
            }
            if (1 <= i) {
                int i2 = 1;
                while (true) {
                    C1422 c1422 = this.f4586.get(i2);
                    if (c1422 == null) {
                        C6635.m9822();
                        throw null;
                    }
                    C1422 c14222 = c1422;
                    if (c14222 != c1422M2758) {
                        while (c14222.isAlive()) {
                            LockSupport.unpark(c14222);
                            c14222.join(j);
                        }
                        C1435 c1435 = c14222.f4592;
                        C1426 c1426 = this.f4585;
                        if (c1435 == null) {
                            throw null;
                        }
                        AbstractRunnableC1430 abstractRunnableC1430 = (AbstractRunnableC1430) C1435.f4627.getAndSet(c1435, null);
                        if (abstractRunnableC1430 != null) {
                            c1426.m2582(abstractRunnableC1430);
                        }
                        do {
                            AbstractRunnableC1430 abstractRunnableC1430M2779 = c1435.m2779();
                            if (abstractRunnableC1430M2779 != null) {
                                c1426.m2582(abstractRunnableC1430M2779);
                                z = true;
                            } else {
                                z = false;
                            }
                        } while (z);
                    }
                    if (i2 == i) {
                        break;
                    } else {
                        i2++;
                    }
                }
            }
            this.f4585.m2581();
            this.f4584.m2581();
            while (true) {
                if (c1422M2758 == null) {
                    abstractRunnableC1430M2584 = this.f4584.m2584();
                } else {
                    abstractRunnableC1430M2584 = c1422M2758.m2765(true);
                    if (abstractRunnableC1430M2584 == null) {
                    }
                }
                if (abstractRunnableC1430M2584 == null) {
                    abstractRunnableC1430M2584 = this.f4585.m2584();
                }
                if (abstractRunnableC1430M2584 == null) {
                    break;
                } else {
                    m2757(abstractRunnableC1430M2584);
                }
            }
            if (c1422M2758 != null) {
                c1422M2758.m2766(EnumC1423.TERMINATED);
            }
            this.parkedWorkersStack = 0L;
            this.controlState = 0L;
        }
    }

    /* JADX INFO: renamed from: އ, reason: contains not printable characters */
    public final boolean m2762(long j) {
        int i = ((int) (2097151 & j)) - ((int) ((j & 4398044413952L) >> 21));
        if (i < 0) {
            i = 0;
        }
        if (i < this.f4587) {
            int iM2752 = m2752();
            if (iM2752 == 1 && this.f4587 > 1) {
                m2752();
            }
            if (iM2752 > 0) {
                return true;
            }
        }
        return false;
    }
}