package androidx.compose.runtime;

import androidx.compose.runtime.RecomposeScopeImpl;
import androidx.compose.runtime.collection.ScopeMap;
import androidx.compose.runtime.tooling.ComposeStackTraceMode;
import java.util.ArrayList;
import java.util.List;
import n.N;
import n.O;
import w4.C3137A;
import x4.AbstractC3251q;
import x4.y;

/* JADX INFO: loaded from: classes.dex */
public final class ComposerKt {
    public static final boolean EnableDebugRuntimeChecks = false;
    public static final int compositionLocalMapKey = 202;
    private static CompositionTracer compositionTracer = null;
    public static final int defaultsKey = -127;
    private static final int invalidGroupLocation = -2;
    public static final int invocationKey = 200;
    public static final int providerKey = 201;
    public static final int providerMapsKey = 204;
    public static final int providerValuesKey = 203;
    public static final int referenceKey = 206;
    public static final int reuseKey = 207;
    private static int composeStackTraceMode = ComposeStackTraceMode.Companion.m280getNoneMD5MrJc();
    private static final Object invocation = new OpaqueKey("provider");
    private static final Object provider = new OpaqueKey("provider");
    private static final Object compositionLocalMap = new OpaqueKey("compositionLocalMap");
    private static final Object providerValues = new OpaqueKey("providerValues");
    private static final Object providerMaps = new OpaqueKey("providers");
    private static final Object reference = new OpaqueKey("reference");

    @ComposeCompilerApi
    public static final <T> T cache(Composer composer, boolean z6, J4.a aVar) {
        T t6 = (T) composer.rememberedValue();
        if (!z6 && t6 != Composer.Companion.getEmpty()) {
            return t6;
        }
        T t7 = (T) aVar.invoke();
        composer.updateRememberedValue(t7);
        return t7;
    }

    public static final void composeImmediateRuntimeError(String str) {
        throw new ComposeRuntimeError(Z0.o.o("Compose Runtime internal error. Unexpected or incorrect use of the Compose internal runtime API (", str, "). Please report to Google or use https://goo.gle/compose-feedback"));
    }

    public static final Void composeRuntimeError(String str) {
        throw new ComposeRuntimeError(Z0.o.o("Compose Runtime internal error. Unexpected or incorrect use of the Compose internal runtime API (", str, "). Please report to Google or use https://goo.gle/compose-feedback"));
    }

    public static final void debugRuntimeCheck(boolean z6) {
    }

    /* JADX WARN: Multi-variable type inference failed */
    /* JADX WARN: Type inference failed for: r8v2, types: [x4.y] */
    /* JADX WARN: Type inference failed for: r8v3, types: [java.lang.Iterable] */
    /* JADX WARN: Type inference failed for: r8v4, types: [java.util.ArrayList] */
    public static final MovableContentState extractMovableContentAtCurrent(final ControlledComposition controlledComposition, MovableContentStateReference movableContentStateReference, SlotWriter slotWriter, Applier<?> applier) {
        final MovableContentStateReference movableContentStateReference2;
        ?? arrayList;
        long[] jArr;
        int i6;
        long[] jArr2;
        int i7;
        long j4;
        int i8;
        boolean zB;
        Object obj;
        long j6;
        int i9;
        Object obj2;
        SlotTable slotTable = new SlotTable();
        if (slotWriter.getCollectingSourceInformation()) {
            slotTable.collectSourceInformation();
        }
        if (slotWriter.getCollectingCalledInformation()) {
            slotTable.collectCalledByInformation();
        }
        int currentGroup = slotWriter.getCurrentGroup();
        if (applier != null && slotWriter.nodeCount(currentGroup) > 0) {
            int parent = slotWriter.getParent();
            while (parent > 0 && !slotWriter.isNode(parent)) {
                parent = slotWriter.parent(parent);
            }
            if (parent >= 0 && slotWriter.isNode(parent)) {
                Object objNode = slotWriter.node(parent);
                int i10 = parent + 1;
                int iGroupSize = slotWriter.groupSize(parent) + parent;
                int iNodeCount = 0;
                while (i10 < iGroupSize) {
                    int iGroupSize2 = slotWriter.groupSize(i10) + i10;
                    if (iGroupSize2 > currentGroup) {
                        break;
                    }
                    iNodeCount += slotWriter.isNode(i10) ? 1 : slotWriter.nodeCount(i10);
                    i10 = iGroupSize2;
                }
                int iNodeCount2 = slotWriter.isNode(currentGroup) ? 1 : slotWriter.nodeCount(currentGroup);
                applier.down(objNode);
                applier.remove(iNodeCount, iNodeCount2);
                applier.up();
            }
        }
        Anchor anchor$runtime = movableContentStateReference.getAnchor$runtime();
        if (anchor$runtime.getValid()) {
            kotlin.jvm.internal.o.f(controlledComposition, "null cannot be cast to non-null type androidx.compose.runtime.CompositionImpl");
            CompositionImpl compositionImpl = (CompositionImpl) controlledComposition;
            if (ScopeMap.m188getSizeimpl(compositionImpl.invalidations) > 0) {
                arrayList = new ArrayList();
                N n6 = compositionImpl.invalidations;
                long[] jArr3 = n6.f21381a;
                int length = jArr3.length - 2;
                if (length >= 0) {
                    int i11 = 0;
                    while (true) {
                        long j7 = jArr3[i11];
                        if ((((~j7) << 7) & j7 & (-9187201950435737472L)) != -9187201950435737472L) {
                            int i12 = 8;
                            int i13 = 8 - ((~(i11 - length)) >>> 31);
                            int i14 = 0;
                            while (i14 < i13) {
                                if ((j7 & 255) < 128) {
                                    int i15 = (i11 << 3) + i14;
                                    int i16 = i12;
                                    Object obj3 = n6.f21382b[i15];
                                    i6 = i14;
                                    Object obj4 = n6.f21383c[i15];
                                    jArr2 = jArr3;
                                    kotlin.jvm.internal.o.f(obj3, "null cannot be cast to non-null type Key of androidx.compose.runtime.collection.ScopeMap");
                                    if (obj4 instanceof O) {
                                        kotlin.jvm.internal.o.f(obj4, "null cannot be cast to non-null type androidx.collection.MutableScatterSet<Scope of androidx.compose.runtime.collection.ScopeMap>");
                                        O o6 = (O) obj4;
                                        Object[] objArr = o6.f21389b;
                                        long[] jArr4 = o6.f21388a;
                                        j4 = j7;
                                        int length2 = jArr4.length - 2;
                                        if (length2 >= 0) {
                                            int i17 = 0;
                                            while (true) {
                                                long j8 = jArr4[i17];
                                                long[] jArr5 = jArr4;
                                                i7 = length;
                                                if ((((~j8) << 7) & j8 & (-9187201950435737472L)) != -9187201950435737472L) {
                                                    int i18 = 8 - ((~(i17 - length2)) >>> 31);
                                                    int i19 = 0;
                                                    while (i19 < i18) {
                                                        if ((j8 & 255) < 128) {
                                                            j6 = j8;
                                                            int i20 = (i17 << 3) + i19;
                                                            Object obj5 = objArr[i20];
                                                            i9 = i19;
                                                            RecomposeScopeImpl recomposeScopeImpl = (RecomposeScopeImpl) obj3;
                                                            obj2 = obj3;
                                                            Anchor anchor = recomposeScopeImpl.getAnchor();
                                                            if (anchor != null && slotWriter.inGroup(anchor$runtime, anchor)) {
                                                                arrayList.add(new w4.k(recomposeScopeImpl, obj5));
                                                                o6.m(i20);
                                                            }
                                                        } else {
                                                            j6 = j8;
                                                            i9 = i19;
                                                            obj2 = obj3;
                                                        }
                                                        j8 = j6 >> i16;
                                                        i19 = i9 + 1;
                                                        obj3 = obj2;
                                                    }
                                                    obj = obj3;
                                                    if (i18 != i16) {
                                                        break;
                                                    }
                                                } else {
                                                    obj = obj3;
                                                }
                                                if (i17 == length2) {
                                                    break;
                                                }
                                                i17++;
                                                length = i7;
                                                jArr4 = jArr5;
                                                obj3 = obj;
                                                i16 = 8;
                                            }
                                        } else {
                                            i7 = length;
                                        }
                                        zB = o6.b();
                                    } else {
                                        i7 = length;
                                        j4 = j7;
                                        kotlin.jvm.internal.o.f(obj4, "null cannot be cast to non-null type Scope of androidx.compose.runtime.collection.ScopeMap");
                                        RecomposeScopeImpl recomposeScopeImpl2 = (RecomposeScopeImpl) obj3;
                                        Anchor anchor2 = recomposeScopeImpl2.getAnchor();
                                        if (anchor2 == null || !slotWriter.inGroup(anchor$runtime, anchor2)) {
                                            zB = false;
                                        } else {
                                            arrayList.add(new w4.k(recomposeScopeImpl2, obj4));
                                            zB = true;
                                        }
                                    }
                                    if (zB) {
                                        n6.k(i15);
                                    }
                                    i8 = 8;
                                } else {
                                    i6 = i14;
                                    jArr2 = jArr3;
                                    i7 = length;
                                    j4 = j7;
                                    i8 = i12;
                                }
                                j7 = j4 >> i8;
                                i14 = i6 + 1;
                                i12 = i8;
                                jArr3 = jArr2;
                                length = i7;
                            }
                            jArr = jArr3;
                            int i21 = length;
                            if (i13 != i12) {
                                break;
                            }
                            length = i21;
                        } else {
                            jArr = jArr3;
                        }
                        if (i11 == length) {
                            break;
                        }
                        i11++;
                        jArr3 = jArr;
                    }
                }
            } else {
                arrayList = y.f26065a;
            }
            movableContentStateReference2 = movableContentStateReference;
            movableContentStateReference2.setInvalidations$runtime(AbstractC3251q.s0(arrayList, movableContentStateReference.getInvalidations$runtime()));
        } else {
            movableContentStateReference2 = movableContentStateReference;
        }
        SlotWriter slotWriterOpenWriter = slotTable.openWriter();
        try {
            slotWriterOpenWriter.beginInsert();
            slotWriterOpenWriter.startGroup(MovableContentKt.movableContentKey, movableContentStateReference2.getContent$runtime());
            SlotWriter.markGroup$default(slotWriterOpenWriter, 0, 1, null);
            slotWriterOpenWriter.update(movableContentStateReference2.getParameter$runtime());
            List<Anchor> listMoveTo = slotWriter.moveTo(movableContentStateReference2.getAnchor$runtime(), 1, slotWriterOpenWriter);
            slotWriterOpenWriter.skipGroup();
            slotWriterOpenWriter.endGroup();
            slotWriterOpenWriter.endInsert();
            slotWriterOpenWriter.close(true);
            MovableContentState movableContentState = new MovableContentState(slotTable);
            RecomposeScopeImpl.Companion companion = RecomposeScopeImpl.Companion;
            if (!companion.hasAnchoredRecomposeScopes$runtime(slotTable, listMoveTo)) {
                return movableContentState;
            }
            RecomposeScopeOwner recomposeScopeOwner = new RecomposeScopeOwner() { // from class: androidx.compose.runtime.ComposerKt$extractMovableContentAtCurrent$movableContentRecomposeScopeOwner$1
                @Override // androidx.compose.runtime.RecomposeScopeOwner
                public InvalidationResult invalidate(RecomposeScopeImpl recomposeScopeImpl3, Object obj6) {
                    InvalidationResult invalidationResultInvalidate;
                    ControlledComposition controlledComposition2 = controlledComposition;
                    RecomposeScopeOwner recomposeScopeOwner2 = controlledComposition2 instanceof RecomposeScopeOwner ? (RecomposeScopeOwner) controlledComposition2 : null;
                    if (recomposeScopeOwner2 == null || (invalidationResultInvalidate = recomposeScopeOwner2.invalidate(recomposeScopeImpl3, obj6)) == null) {
                        invalidationResultInvalidate = InvalidationResult.IGNORED;
                    }
                    if (invalidationResultInvalidate != InvalidationResult.IGNORED) {
                        return invalidationResultInvalidate;
                    }
                    MovableContentStateReference movableContentStateReference3 = movableContentStateReference2;
                    movableContentStateReference3.setInvalidations$runtime(AbstractC3251q.t0(movableContentStateReference3.getInvalidations$runtime(), new w4.k(recomposeScopeImpl3, obj6)));
                    return InvalidationResult.SCHEDULED;
                }

                @Override // androidx.compose.runtime.RecomposeScopeOwner
                public void recomposeScopeReleased(RecomposeScopeImpl recomposeScopeImpl3) {
                }

                @Override // androidx.compose.runtime.RecomposeScopeOwner
                public void recordReadOf(Object obj6) {
                }
            };
            slotWriterOpenWriter = slotTable.openWriter();
            try {
                companion.adoptAnchoredScopes$runtime(slotWriterOpenWriter, listMoveTo, recomposeScopeOwner);
                slotWriterOpenWriter.close(true);
                return movableContentState;
            } finally {
            }
        } finally {
        }
    }

    public static final int getComposeStackTraceMode() {
        return composeStackTraceMode;
    }

    public static final Object getCompositionLocalMap() {
        return compositionLocalMap;
    }

    public static /* synthetic */ void getCompositionLocalMap$annotations() {
    }

    public static /* synthetic */ void getCompositionLocalMapKey$annotations() {
    }

    private static /* synthetic */ void getCompositionTracer$annotations() {
    }

    public static final Object getInvocation() {
        return invocation;
    }

    public static /* synthetic */ void getInvocation$annotations() {
    }

    public static /* synthetic */ void getInvocationKey$annotations() {
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final int getNextGroup(SlotWriter slotWriter) {
        return slotWriter.groupSize(slotWriter.getCurrentGroup()) + slotWriter.getCurrentGroup();
    }

    public static final Object getProvider() {
        return provider;
    }

    public static /* synthetic */ void getProvider$annotations() {
    }

    public static /* synthetic */ void getProviderKey$annotations() {
    }

    public static final Object getProviderMaps() {
        return providerMaps;
    }

    public static /* synthetic */ void getProviderMaps$annotations() {
    }

    public static /* synthetic */ void getProviderMapsKey$annotations() {
    }

    public static final Object getProviderValues() {
        return providerValues;
    }

    public static /* synthetic */ void getProviderValues$annotations() {
    }

    public static /* synthetic */ void getProviderValuesKey$annotations() {
    }

    public static final Object getReference() {
        return reference;
    }

    public static /* synthetic */ void getReference$annotations() {
    }

    public static /* synthetic */ void getReferenceKey$annotations() {
    }

    public static /* synthetic */ void getReuseKey$annotations() {
    }

    public static final boolean isAfterFirstChild(SlotWriter slotWriter) {
        return slotWriter.getCurrentGroup() > slotWriter.getParent() + 1;
    }

    @ComposeCompilerApi
    public static final boolean isTraceInProgress() {
        CompositionTracer compositionTracer2 = compositionTracer;
        return compositionTracer2 != null && compositionTracer2.isTraceInProgress();
    }

    public static final void removeCurrentGroup(SlotWriter slotWriter, RememberManager rememberManager) {
        slotWriter.forAllDataInRememberOrder(slotWriter.getCurrentGroup(), new t(rememberManager, 2));
        slotWriter.removeGroup();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final C3137A removeCurrentGroup$lambda$0(RememberManager rememberManager, int i6, Object obj) {
        if (obj instanceof ComposeNodeLifecycleCallback) {
            rememberManager.releasing((ComposeNodeLifecycleCallback) obj);
        }
        if (obj instanceof RememberObserverHolder) {
            rememberManager.forgetting((RememberObserverHolder) obj);
        }
        if (obj instanceof RecomposeScopeImpl) {
            ((RecomposeScopeImpl) obj).release();
        }
        return C3137A.f25453a;
    }

    public static final void runtimeCheck(boolean z6, J4.a aVar) {
        if (z6) {
            return;
        }
        composeImmediateRuntimeError((String) aVar.invoke());
    }

    /* JADX INFO: renamed from: setComposeStackTraceMode-76WK1J0, reason: not valid java name */
    public static final void m24setComposeStackTraceMode76WK1J0(int i6) {
        composeStackTraceMode = i6;
    }

    @ComposeCompilerApi
    public static final void sourceInformation(Composer composer, String str) {
        composer.sourceInformation(str);
    }

    @ComposeCompilerApi
    public static final void sourceInformationMarkerEnd(Composer composer) {
        composer.sourceInformationMarkerEnd();
    }

    @ComposeCompilerApi
    public static final void sourceInformationMarkerStart(Composer composer, int i6, String str) {
        composer.sourceInformationMarkerStart(i6, str);
    }

    @ComposeCompilerApi
    public static final void traceEventEnd() {
        CompositionTracer compositionTracer2 = compositionTracer;
        if (compositionTracer2 != null) {
            compositionTracer2.traceEventEnd();
        }
    }

    public static final <R> void withAfterAnchorInfo(SlotWriter slotWriter, Anchor anchor, J4.e eVar) {
        int iAnchorIndex;
        int slotsSize;
        if (anchor == null || !anchor.getValid()) {
            iAnchorIndex = -1;
            slotsSize = -1;
        } else {
            iAnchorIndex = slotWriter.anchorIndex(anchor);
            slotsSize = slotWriter.getSlotsSize() - slotWriter.slotsEndAllIndex$runtime(iAnchorIndex);
        }
        eVar.invoke(Integer.valueOf(iAnchorIndex), Integer.valueOf(slotsSize));
    }

    public static final void debugRuntimeCheck(boolean z6, J4.a aVar) {
    }

    public static final boolean isAfterFirstChild(SlotReader slotReader) {
        return slotReader.getCurrentGroup() > slotReader.getParent() + 1;
    }

    public static final void runtimeCheck(boolean z6) {
        if (z6) {
            return;
        }
        composeImmediateRuntimeError("Check failed");
    }

    @ComposeCompilerApi
    public static final void traceEventStart(int i6, int i7, int i8, String str) {
        CompositionTracer compositionTracer2 = compositionTracer;
        if (compositionTracer2 != null) {
            compositionTracer2.traceEventStart(i6, i7, i8, str);
        }
    }
}