package androidx.compose.runtime.snapshots;

import E3.v;
import androidx.compose.runtime.PreconditionsKt;
import androidx.compose.runtime.collection.ScatterSetWrapperKt;
import androidx.compose.runtime.external.kotlinx.collections.immutable.PersistentList;
import androidx.compose.runtime.internal.StabilityInferred;
import androidx.compose.runtime.snapshots.SnapshotApplyResult;
import androidx.compose.runtime.snapshots.tooling.SnapshotInstanceObservers;
import androidx.compose.runtime.snapshots.tooling.SnapshotObserverKt;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
import kotlin.jvm.internal.h;
import kotlin.jvm.internal.o;
import n.O;
import n.a0;
import w4.k;
import x4.AbstractC3251q;
import x4.y;

/* JADX INFO: loaded from: classes.dex */
@StabilityInferred(parameters = 0)
public class MutableSnapshot extends Snapshot {
    private boolean applied;
    private List<? extends StateObject> merged;
    private O modified;
    private SnapshotIdSet previousIds;
    private int[] previousPinnedSnapshots;
    private final J4.c readObserver;
    private int snapshots;
    private int writeCount;
    private final J4.c writeObserver;
    private static final Companion Companion = new Companion(null);
    public static final int $stable = 8;
    private static final int[] EmptyIntArray = new int[0];

    public static final class Companion {
        public /* synthetic */ Companion(h hVar) {
            this();
        }

        private Companion() {
        }
    }

    public MutableSnapshot(long j4, SnapshotIdSet snapshotIdSet, J4.c cVar, J4.c cVar2) {
        super(j4, snapshotIdSet, (h) null);
        this.readObserver = cVar;
        this.writeObserver = cVar2;
        this.previousIds = SnapshotIdSet.Companion.getEMPTY();
        this.previousPinnedSnapshots = EmptyIntArray;
        this.snapshots = 1;
    }

    /* JADX WARN: Removed duplicated region for block: B:23:0x007a  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    private final void abandon() {
        O modified$runtime = getModified$runtime();
        if (modified$runtime != null) {
            validateNotApplied();
            setModified$runtime(null);
            long snapshotId = getSnapshotId();
            Object[] objArr = modified$runtime.f21389b;
            long[] jArr = modified$runtime.f21388a;
            int length = jArr.length - 2;
            if (length >= 0) {
                int i6 = 0;
                while (true) {
                    long j4 = jArr[i6];
                    if ((((~j4) << 7) & j4 & (-9187201950435737472L)) != -9187201950435737472L) {
                        int i7 = 8 - ((~(i6 - length)) >>> 31);
                        for (int i8 = 0; i8 < i7; i8++) {
                            if ((255 & j4) < 128) {
                                for (StateRecord firstStateRecord = ((StateObject) objArr[(i6 << 3) + i8]).getFirstStateRecord(); firstStateRecord != null; firstStateRecord = firstStateRecord.getNext$runtime()) {
                                    if (firstStateRecord.getSnapshotId$runtime() == snapshotId || AbstractC3251q.Y(this.previousIds, Long.valueOf(firstStateRecord.getSnapshotId$runtime()))) {
                                        firstStateRecord.setSnapshotId$runtime(SnapshotKt.INVALID_SNAPSHOT);
                                    }
                                }
                            }
                            j4 >>= 8;
                        }
                        if (i7 != 8) {
                            break;
                        } else if (i6 == length) {
                            break;
                        } else {
                            i6++;
                        }
                    }
                }
            }
        }
        closeAndReleasePinning$runtime();
    }

    private final void releasePreviouslyPinnedSnapshotsLocked() {
        int length = this.previousPinnedSnapshots.length;
        for (int i6 = 0; i6 < length; i6++) {
            SnapshotKt.releasePinningLocked(this.previousPinnedSnapshots[i6]);
        }
    }

    public static /* synthetic */ MutableSnapshot takeNestedMutableSnapshot$default(MutableSnapshot mutableSnapshot, J4.c cVar, J4.c cVar2, int i6, Object obj) {
        if (obj != null) {
            throw new UnsupportedOperationException("Super calls with default arguments not supported in this target, function: takeNestedMutableSnapshot");
        }
        if ((i6 & 1) != 0) {
            cVar = null;
        }
        if ((i6 & 2) != 0) {
            cVar2 = null;
        }
        return mutableSnapshot.takeNestedMutableSnapshot(cVar, cVar2);
    }

    private final void validateNotApplied() {
        if (this.applied) {
            PreconditionsKt.throwIllegalStateException("Unsupported operation on a snapshot that has been applied");
        }
    }

    private final void validateNotAppliedOrPinned() {
        if (!this.applied || ((Snapshot) this).pinningTrackingHandle >= 0) {
            return;
        }
        PreconditionsKt.throwIllegalStateException("Unsupported operation on a disposed or applied snapshot");
    }

    public final <T> T advance$runtime(J4.a aVar) {
        long j4;
        recordPrevious$runtime(getSnapshotId());
        T t6 = (T) aVar.invoke();
        if (getApplied$runtime() || getDisposed$runtime()) {
            return t6;
        }
        long snapshotId = getSnapshotId();
        synchronized (SnapshotKt.getLock()) {
            long j6 = SnapshotKt.nextSnapshotId;
            j4 = 1;
            SnapshotKt.nextSnapshotId += j4;
            setSnapshotId$runtime(j6);
            SnapshotKt.openSnapshots = SnapshotKt.openSnapshots.set(getSnapshotId());
        }
        setInvalid$runtime(SnapshotKt.addRange(getInvalid$runtime(), snapshotId + j4, getSnapshotId()));
        return t6;
    }

    /* JADX WARN: Removed duplicated region for block: B:59:0x012f  */
    /* JADX WARN: Removed duplicated region for block: B:61:0x0134  */
    /* JADX WARN: Removed duplicated region for block: B:75:0x016e  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public SnapshotApplyResult apply() {
        Map<StateRecord, ? extends StateRecord> mapOptimisticMerges;
        List list;
        O modified$runtime;
        long j4;
        long j6;
        O modified$runtime2 = getModified$runtime();
        if (modified$runtime2 != null) {
            GlobalSnapshot globalSnapshot = SnapshotKt.globalSnapshot;
            mapOptimisticMerges = SnapshotKt.optimisticMerges(globalSnapshot.getSnapshotId(), this, SnapshotKt.openSnapshots.clear(globalSnapshot.getSnapshotId()));
        } else {
            mapOptimisticMerges = null;
        }
        y yVar = y.f26065a;
        synchronized (SnapshotKt.getLock()) {
            try {
                SnapshotKt.validateOpen(this);
                if (modified$runtime2 == null || modified$runtime2.f21391d == 0) {
                    closeLocked$runtime();
                    GlobalSnapshot globalSnapshot2 = SnapshotKt.globalSnapshot;
                    O modified$runtime3 = globalSnapshot2.getModified$runtime();
                    SnapshotKt.resetGlobalSnapshotLocked(globalSnapshot2, SnapshotKt.emptyLambda);
                    if (modified$runtime3 == null || !modified$runtime3.c()) {
                        list = yVar;
                        modified$runtime = null;
                    } else {
                        list = SnapshotKt.applyObservers;
                        modified$runtime = modified$runtime3;
                    }
                } else {
                    GlobalSnapshot globalSnapshot3 = SnapshotKt.globalSnapshot;
                    SnapshotApplyResult snapshotApplyResultInnerApplyLocked$runtime = innerApplyLocked$runtime(SnapshotKt.nextSnapshotId, modified$runtime2, mapOptimisticMerges, SnapshotKt.openSnapshots.clear(globalSnapshot3.getSnapshotId()));
                    if (!o.c(snapshotApplyResultInnerApplyLocked$runtime, SnapshotApplyResult.Success.INSTANCE)) {
                        return snapshotApplyResultInnerApplyLocked$runtime;
                    }
                    closeLocked$runtime();
                    modified$runtime = globalSnapshot3.getModified$runtime();
                    SnapshotKt.resetGlobalSnapshotLocked(globalSnapshot3, SnapshotKt.emptyLambda);
                    setModified$runtime(null);
                    globalSnapshot3.setModified$runtime(null);
                    list = SnapshotKt.applyObservers;
                }
                this.applied = true;
                if (modified$runtime != null) {
                    Set setWrapIntoSet = ScatterSetWrapperKt.wrapIntoSet(modified$runtime);
                    if (!setWrapIntoSet.isEmpty()) {
                        int size = list.size();
                        for (int i6 = 0; i6 < size; i6++) {
                            ((J4.e) list.get(i6)).invoke(setWrapIntoSet, this);
                        }
                    }
                }
                if (modified$runtime2 != null && modified$runtime2.c()) {
                    Set setWrapIntoSet2 = ScatterSetWrapperKt.wrapIntoSet(modified$runtime2);
                    int size2 = list.size();
                    for (int i7 = 0; i7 < size2; i7++) {
                        ((J4.e) list.get(i7)).invoke(setWrapIntoSet2, this);
                    }
                }
                SnapshotObserverKt.dispatchObserverOnApplied(this, modified$runtime2);
                synchronized (SnapshotKt.getLock()) {
                    try {
                        releasePinnedSnapshotsForCloseLocked$runtime();
                        SnapshotKt.checkAndOverwriteUnusedRecordsLocked();
                        if (modified$runtime != null) {
                            Object[] objArr = modified$runtime.f21389b;
                            long[] jArr = modified$runtime.f21388a;
                            int length = jArr.length - 2;
                            if (length >= 0) {
                                int i8 = 0;
                                j4 = 128;
                                while (true) {
                                    long j7 = jArr[i8];
                                    j6 = 255;
                                    if ((((~j7) << 7) & j7 & (-9187201950435737472L)) != -9187201950435737472L) {
                                        int i9 = 8 - ((~(i8 - length)) >>> 31);
                                        for (int i10 = 0; i10 < i9; i10++) {
                                            if ((j7 & 255) < 128) {
                                                SnapshotKt.processForUnusedRecordsLocked((StateObject) objArr[(i8 << 3) + i10]);
                                            }
                                            j7 >>= 8;
                                        }
                                        if (i9 != 8) {
                                            break;
                                        }
                                        if (i8 == length) {
                                            break;
                                        }
                                        i8++;
                                    }
                                }
                            } else {
                                j4 = 128;
                                j6 = 255;
                            }
                        }
                        if (modified$runtime2 != null) {
                            Object[] objArr2 = modified$runtime2.f21389b;
                            long[] jArr2 = modified$runtime2.f21388a;
                            int length2 = jArr2.length - 2;
                            if (length2 >= 0) {
                                int i11 = 0;
                                while (true) {
                                    long j8 = jArr2[i11];
                                    if ((((~j8) << 7) & j8 & (-9187201950435737472L)) != -9187201950435737472L) {
                                        int i12 = 8 - ((~(i11 - length2)) >>> 31);
                                        for (int i13 = 0; i13 < i12; i13++) {
                                            if ((j8 & j6) < j4) {
                                                SnapshotKt.processForUnusedRecordsLocked((StateObject) objArr2[(i11 << 3) + i13]);
                                            }
                                            j8 >>= 8;
                                        }
                                        if (i12 != 8) {
                                            break;
                                        }
                                        if (i11 == length2) {
                                            break;
                                        }
                                        i11++;
                                    }
                                }
                            }
                        }
                        List<? extends StateObject> list2 = this.merged;
                        if (list2 != null) {
                            int size3 = list2.size();
                            for (int i14 = 0; i14 < size3; i14++) {
                                SnapshotKt.processForUnusedRecordsLocked(list2.get(i14));
                            }
                        }
                        this.merged = null;
                    } catch (Throwable th) {
                        throw th;
                    }
                }
                return SnapshotApplyResult.Success.INSTANCE;
            } catch (Throwable th2) {
                throw th2;
            }
        }
    }

    @Override // androidx.compose.runtime.snapshots.Snapshot
    public void closeLocked$runtime() {
        SnapshotKt.openSnapshots = SnapshotKt.openSnapshots.clear(getSnapshotId()).andNot(this.previousIds);
    }

    @Override // androidx.compose.runtime.snapshots.Snapshot
    public void dispose() {
        if (getDisposed$runtime()) {
            return;
        }
        super.dispose();
        mo254nestedDeactivated$runtime(this);
        SnapshotObserverKt.dispatchObserverOnPreDispose(this);
    }

    public final boolean getApplied$runtime() {
        return this.applied;
    }

    public final List<StateObject> getMerged$runtime() {
        return this.merged;
    }

    @Override // androidx.compose.runtime.snapshots.Snapshot
    public O getModified$runtime() {
        return this.modified;
    }

    public final SnapshotIdSet getPreviousIds$runtime() {
        return this.previousIds;
    }

    public final int[] getPreviousPinnedSnapshots$runtime() {
        return this.previousPinnedSnapshots;
    }

    @Override // androidx.compose.runtime.snapshots.Snapshot
    /* JADX INFO: renamed from: getReadObserver$runtime */
    public J4.c getReadObserver() {
        return this.readObserver;
    }

    @Override // androidx.compose.runtime.snapshots.Snapshot
    public boolean getReadOnly() {
        return false;
    }

    @Override // androidx.compose.runtime.snapshots.Snapshot
    public Snapshot getRoot() {
        return this;
    }

    @Override // androidx.compose.runtime.snapshots.Snapshot
    public int getWriteCount$runtime() {
        return this.writeCount;
    }

    @Override // androidx.compose.runtime.snapshots.Snapshot
    public J4.c getWriteObserver$runtime() {
        return this.writeObserver;
    }

    @Override // androidx.compose.runtime.snapshots.Snapshot
    public boolean hasPendingChanges() {
        O modified$runtime = getModified$runtime();
        return modified$runtime != null && modified$runtime.c();
    }

    public final SnapshotApplyResult innerApplyLocked$runtime(long j4, O o6, Map<StateRecord, ? extends StateRecord> map, SnapshotIdSet snapshotIdSet) {
        SnapshotIdSet snapshotIdSet2;
        Object[] objArr;
        long[] jArr;
        SnapshotIdSet snapshotIdSet3;
        Object[] objArr2;
        long[] jArr2;
        int i6;
        long j6;
        int i7;
        StateRecord stateRecordMergeRecords;
        SnapshotIdSet snapshotIdSetOr = getInvalid$runtime().set(getSnapshotId()).or(this.previousIds);
        Object[] objArr3 = o6.f21389b;
        long[] jArr3 = o6.f21388a;
        int length = jArr3.length - 2;
        ArrayList arrayList = null;
        ArrayList arrayListS0 = null;
        if (length >= 0) {
            int i8 = 0;
            while (true) {
                long j7 = jArr3[i8];
                ArrayList arrayList2 = arrayListS0;
                if ((((~j7) << 7) & j7 & (-9187201950435737472L)) != -9187201950435737472L) {
                    int i9 = 8;
                    int i10 = 8 - ((~(i8 - length)) >>> 31);
                    int i11 = 0;
                    while (i11 < i10) {
                        if ((j7 & 255) < 128) {
                            i6 = i9;
                            StateObject stateObject = (StateObject) objArr3[(i8 << 3) + i11];
                            objArr2 = objArr3;
                            StateRecord firstStateRecord = stateObject.getFirstStateRecord();
                            jArr2 = jArr3;
                            ArrayList arrayList3 = arrayList;
                            StateRecord stateRecord = SnapshotKt.readable(firstStateRecord, j4, snapshotIdSet);
                            if (stateRecord == null) {
                                j6 = j7;
                            } else {
                                j6 = j7;
                                StateRecord stateRecord2 = SnapshotKt.readable(firstStateRecord, getSnapshotId(), snapshotIdSetOr);
                                if (stateRecord2 != null && stateRecord2.getSnapshotId$runtime() != SnapshotId_jvmKt.toSnapshotId(1) && !stateRecord.equals(stateRecord2)) {
                                    i7 = i11;
                                    snapshotIdSet3 = snapshotIdSetOr;
                                    StateRecord stateRecord3 = SnapshotKt.readable(firstStateRecord, getSnapshotId(), getInvalid$runtime());
                                    if (stateRecord3 == null) {
                                        SnapshotKt.readError();
                                        throw new v();
                                    }
                                    if (map == null || (stateRecordMergeRecords = map.get(stateRecord)) == null) {
                                        stateRecordMergeRecords = stateObject.mergeRecords(stateRecord2, stateRecord, stateRecord3);
                                    }
                                    if (stateRecordMergeRecords == null) {
                                        return new SnapshotApplyResult.Failure(this);
                                    }
                                    if (!stateRecordMergeRecords.equals(stateRecord3)) {
                                        if (stateRecordMergeRecords.equals(stateRecord)) {
                                            ArrayList arrayList4 = arrayList3 == null ? new ArrayList() : arrayList3;
                                            arrayList4.add(new k(stateObject, stateRecord.create(getSnapshotId())));
                                            if (arrayList2 == null) {
                                                arrayList2 = new ArrayList();
                                            }
                                            ArrayList arrayList5 = arrayList2;
                                            arrayList5.add(stateObject);
                                            arrayList = arrayList4;
                                            arrayList2 = arrayList5;
                                        } else {
                                            arrayList = arrayList3 == null ? new ArrayList() : arrayList3;
                                            arrayList.add(!stateRecordMergeRecords.equals(stateRecord2) ? new k(stateObject, stateRecordMergeRecords) : new k(stateObject, stateRecord2.create(getSnapshotId())));
                                        }
                                    }
                                }
                                arrayList = arrayList3;
                            }
                            snapshotIdSet3 = snapshotIdSetOr;
                            i7 = i11;
                            arrayList = arrayList3;
                        } else {
                            snapshotIdSet3 = snapshotIdSetOr;
                            objArr2 = objArr3;
                            jArr2 = jArr3;
                            i6 = i9;
                            j6 = j7;
                            i7 = i11;
                        }
                        j7 = j6 >> i6;
                        i11 = i7 + 1;
                        objArr3 = objArr2;
                        i9 = i6;
                        jArr3 = jArr2;
                        snapshotIdSetOr = snapshotIdSet3;
                    }
                    snapshotIdSet2 = snapshotIdSetOr;
                    objArr = objArr3;
                    jArr = jArr3;
                    ArrayList arrayList6 = arrayList;
                    if (i10 != i9) {
                        arrayListS0 = arrayList2;
                        arrayList = arrayList6;
                        break;
                    }
                    arrayList = arrayList6;
                } else {
                    snapshotIdSet2 = snapshotIdSetOr;
                    objArr = objArr3;
                    jArr = jArr3;
                }
                arrayListS0 = arrayList2;
                if (i8 == length) {
                    break;
                }
                i8++;
                objArr3 = objArr;
                jArr3 = jArr;
                snapshotIdSetOr = snapshotIdSet2;
            }
        }
        if (arrayList != null) {
            advance$runtime();
            int size = arrayList.size();
            for (int i12 = 0; i12 < size; i12++) {
                k kVar = (k) arrayList.get(i12);
                StateObject stateObject2 = (StateObject) kVar.f25469a;
                StateRecord stateRecord4 = (StateRecord) kVar.f25470b;
                stateRecord4.setSnapshotId$runtime(j4);
                synchronized (SnapshotKt.getLock()) {
                    stateRecord4.setNext$runtime(stateObject2.getFirstStateRecord());
                    stateObject2.prependStateRecord(stateRecord4);
                }
            }
        }
        if (arrayListS0 != null) {
            int size2 = arrayListS0.size();
            for (int i13 = 0; i13 < size2; i13++) {
                o6.l((StateObject) arrayListS0.get(i13));
            }
            List<? extends StateObject> list = this.merged;
            if (list != null) {
                arrayListS0 = AbstractC3251q.s0(arrayListS0, list);
            }
            this.merged = arrayListS0;
        }
        return SnapshotApplyResult.Success.INSTANCE;
    }

    @Override // androidx.compose.runtime.snapshots.Snapshot
    /* JADX INFO: renamed from: nestedActivated$runtime */
    public void mo253nestedActivated$runtime(Snapshot snapshot) {
        this.snapshots++;
    }

    @Override // androidx.compose.runtime.snapshots.Snapshot
    /* JADX INFO: renamed from: nestedDeactivated$runtime */
    public void mo254nestedDeactivated$runtime(Snapshot snapshot) {
        if (!(this.snapshots > 0)) {
            PreconditionsKt.throwIllegalArgumentException("no pending nested snapshots");
        }
        int i6 = this.snapshots - 1;
        this.snapshots = i6;
        if (i6 != 0 || this.applied) {
            return;
        }
        abandon();
    }

    @Override // androidx.compose.runtime.snapshots.Snapshot
    public void notifyObjectsInitialized$runtime() {
        if (this.applied || getDisposed$runtime()) {
            return;
        }
        advance$runtime();
    }

    @Override // androidx.compose.runtime.snapshots.Snapshot
    /* JADX INFO: renamed from: recordModified$runtime */
    public void mo255recordModified$runtime(StateObject stateObject) {
        O modified$runtime = getModified$runtime();
        if (modified$runtime == null) {
            O o6 = a0.f21397a;
            modified$runtime = new O();
            setModified$runtime(modified$runtime);
        }
        modified$runtime.d(stateObject);
    }

    public final void recordPrevious$runtime(long j4) {
        synchronized (SnapshotKt.getLock()) {
            this.previousIds = this.previousIds.set(j4);
        }
    }

    public final void recordPreviousList$runtime(SnapshotIdSet snapshotIdSet) {
        synchronized (SnapshotKt.getLock()) {
            this.previousIds = this.previousIds.or(snapshotIdSet);
        }
    }

    public final void recordPreviousPinnedSnapshot$runtime(int i6) {
        if (i6 >= 0) {
            int[] iArr = this.previousPinnedSnapshots;
            o.h(iArr, "<this>");
            int length = iArr.length;
            int[] iArrCopyOf = Arrays.copyOf(iArr, length + 1);
            iArrCopyOf[length] = i6;
            this.previousPinnedSnapshots = iArrCopyOf;
        }
    }

    public final void recordPreviousPinnedSnapshots$runtime(int[] iArr) {
        if (iArr.length == 0) {
            return;
        }
        int[] iArr2 = this.previousPinnedSnapshots;
        if (iArr2.length != 0) {
            int length = iArr2.length;
            int length2 = iArr.length;
            int[] iArrCopyOf = Arrays.copyOf(iArr2, length + length2);
            System.arraycopy(iArr, 0, iArrCopyOf, length, length2);
            o.e(iArrCopyOf);
            iArr = iArrCopyOf;
        }
        this.previousPinnedSnapshots = iArr;
    }

    @Override // androidx.compose.runtime.snapshots.Snapshot
    public void releasePinnedSnapshotsForCloseLocked$runtime() {
        releasePreviouslyPinnedSnapshotsLocked();
        super.releasePinnedSnapshotsForCloseLocked$runtime();
    }

    public final void setApplied$runtime(boolean z6) {
        this.applied = z6;
    }

    public final void setMerged$runtime(List<? extends StateObject> list) {
        this.merged = list;
    }

    public void setModified$runtime(O o6) {
        this.modified = o6;
    }

    public final void setPreviousIds$runtime(SnapshotIdSet snapshotIdSet) {
        this.previousIds = snapshotIdSet;
    }

    public final void setPreviousPinnedSnapshots$runtime(int[] iArr) {
        this.previousPinnedSnapshots = iArr;
    }

    @Override // androidx.compose.runtime.snapshots.Snapshot
    public void setWriteCount$runtime(int i6) {
        this.writeCount = i6;
    }

    public MutableSnapshot takeNestedMutableSnapshot(J4.c cVar, J4.c cVar2) {
        Map map;
        long j4;
        NestedMutableSnapshot nestedMutableSnapshot;
        validateNotDisposed$runtime();
        validateNotAppliedOrPinned();
        PersistentList persistentList = SnapshotObserverKt.observers;
        J4.c cVar3 = cVar;
        J4.c writeObserver = cVar2;
        if (persistentList != null) {
            k kVarMergeObservers = SnapshotObserverKt.mergeObservers(persistentList, this, false, cVar3, writeObserver);
            SnapshotInstanceObservers snapshotInstanceObservers = (SnapshotInstanceObservers) kVarMergeObservers.f25469a;
            J4.c readObserver = snapshotInstanceObservers.getReadObserver();
            writeObserver = snapshotInstanceObservers.getWriteObserver();
            map = (Map) kVarMergeObservers.f25470b;
            cVar3 = readObserver;
        } else {
            map = null;
        }
        recordPrevious$runtime(getSnapshotId());
        synchronized (SnapshotKt.getLock()) {
            long j6 = SnapshotKt.nextSnapshotId;
            j4 = 1;
            SnapshotKt.nextSnapshotId += j4;
            SnapshotKt.openSnapshots = SnapshotKt.openSnapshots.set(j6);
            SnapshotIdSet invalid$runtime = getInvalid$runtime();
            setInvalid$runtime(invalid$runtime.set(j6));
            nestedMutableSnapshot = new NestedMutableSnapshot(j6, SnapshotKt.addRange(invalid$runtime, getSnapshotId() + j4, j6), SnapshotKt.mergedReadObserver$default(cVar3, getReadObserver(), false, 4, null), SnapshotKt.mergedWriteObserver(writeObserver, getWriteObserver$runtime()), this);
        }
        if (!getApplied$runtime() && !getDisposed$runtime()) {
            long snapshotId = getSnapshotId();
            synchronized (SnapshotKt.getLock()) {
                long j7 = SnapshotKt.nextSnapshotId;
                SnapshotKt.nextSnapshotId += j4;
                setSnapshotId$runtime(j7);
                SnapshotKt.openSnapshots = SnapshotKt.openSnapshots.set(getSnapshotId());
            }
            setInvalid$runtime(SnapshotKt.addRange(getInvalid$runtime(), snapshotId + j4, getSnapshotId()));
        }
        if (persistentList != null) {
            SnapshotObserverKt.dispatchCreatedObservers(persistentList, this, nestedMutableSnapshot, map);
        }
        return nestedMutableSnapshot;
    }

    @Override // androidx.compose.runtime.snapshots.Snapshot
    public Snapshot takeNestedSnapshot(J4.c cVar) {
        Map map;
        long j4;
        NestedReadonlySnapshot nestedReadonlySnapshot;
        validateNotDisposed$runtime();
        validateNotAppliedOrPinned();
        long snapshotId = getSnapshotId();
        MutableSnapshot mutableSnapshot = this instanceof GlobalSnapshot ? null : this;
        PersistentList persistentList = SnapshotObserverKt.observers;
        J4.c cVar2 = cVar;
        if (persistentList != null) {
            k kVarMergeObservers = SnapshotObserverKt.mergeObservers(persistentList, mutableSnapshot, true, cVar2, null);
            SnapshotInstanceObservers snapshotInstanceObservers = (SnapshotInstanceObservers) kVarMergeObservers.f25469a;
            J4.c readObserver = snapshotInstanceObservers.getReadObserver();
            snapshotInstanceObservers.getWriteObserver();
            map = (Map) kVarMergeObservers.f25470b;
            cVar2 = readObserver;
        } else {
            map = null;
        }
        recordPrevious$runtime(getSnapshotId());
        synchronized (SnapshotKt.getLock()) {
            long j6 = SnapshotKt.nextSnapshotId;
            j4 = 1;
            SnapshotKt.nextSnapshotId += j4;
            SnapshotKt.openSnapshots = SnapshotKt.openSnapshots.set(j6);
            nestedReadonlySnapshot = new NestedReadonlySnapshot(j6, SnapshotKt.addRange(getInvalid$runtime(), snapshotId + j4, j6), SnapshotKt.mergedReadObserver$default(cVar2, getReadObserver(), false, 4, null), this);
        }
        if (!getApplied$runtime() && !getDisposed$runtime()) {
            long snapshotId2 = getSnapshotId();
            synchronized (SnapshotKt.getLock()) {
                long j7 = SnapshotKt.nextSnapshotId;
                SnapshotKt.nextSnapshotId += j4;
                setSnapshotId$runtime(j7);
                SnapshotKt.openSnapshots = SnapshotKt.openSnapshots.set(getSnapshotId());
            }
            setInvalid$runtime(SnapshotKt.addRange(getInvalid$runtime(), snapshotId2 + j4, getSnapshotId()));
        }
        if (persistentList != null) {
            SnapshotObserverKt.dispatchCreatedObservers(persistentList, mutableSnapshot, nestedReadonlySnapshot, map);
        }
        return nestedReadonlySnapshot;
    }

    public final void advance$runtime() {
        long j4;
        recordPrevious$runtime(getSnapshotId());
        if (getApplied$runtime() || getDisposed$runtime()) {
            return;
        }
        long snapshotId = getSnapshotId();
        synchronized (SnapshotKt.getLock()) {
            long j6 = SnapshotKt.nextSnapshotId;
            j4 = 1;
            SnapshotKt.nextSnapshotId += j4;
            setSnapshotId$runtime(j6);
            SnapshotKt.openSnapshots = SnapshotKt.openSnapshots.set(getSnapshotId());
        }
        setInvalid$runtime(SnapshotKt.addRange(getInvalid$runtime(), snapshotId + j4, getSnapshotId()));
    }
}