package androidx.compose.runtime.external.kotlinx.collections.immutable.implementations.immutableMap;

import J4.c;
import L4.a;
import P4.e;
import androidx.compose.runtime.PreconditionsKt;
import androidx.compose.runtime.external.kotlinx.collections.immutable.internal.CommonFunctionsKt;
import androidx.compose.runtime.external.kotlinx.collections.immutable.internal.DeltaCounter;
import androidx.compose.runtime.external.kotlinx.collections.immutable.internal.MutabilityOwnership;
import androidx.compose.runtime.internal.StabilityInferred;
import java.util.Arrays;
import kotlin.jvm.internal.h;
import kotlin.jvm.internal.o;

/* JADX INFO: loaded from: classes.dex */
@StabilityInferred(parameters = 0)
public final class TrieNode<K, V> {
    private Object[] buffer;
    private int dataMap;
    private int nodeMap;
    private final MutabilityOwnership ownedBy;
    public static final Companion Companion = new Companion(null);
    public static final int $stable = 8;
    private static final TrieNode EMPTY = new TrieNode(0, 0, new Object[0]);

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

        public final TrieNode getEMPTY$runtime() {
            return TrieNode.EMPTY;
        }

        private Companion() {
        }
    }

    @StabilityInferred(parameters = 0)
    public static final class ModificationResult<K, V> {
        public static final int $stable = 8;
        private TrieNode<K, V> node;
        private final int sizeDelta;

        public ModificationResult(TrieNode<K, V> trieNode, int i6) {
            this.node = trieNode;
            this.sizeDelta = i6;
        }

        public final TrieNode<K, V> getNode() {
            return this.node;
        }

        public final int getSizeDelta() {
            return this.sizeDelta;
        }

        public final ModificationResult<K, V> replaceNode(c cVar) {
            setNode((TrieNode) cVar.invoke(getNode()));
            return this;
        }

        public final void setNode(TrieNode<K, V> trieNode) {
            this.node = trieNode;
        }
    }

    public TrieNode(int i6, int i7, Object[] objArr, MutabilityOwnership mutabilityOwnership) {
        this.dataMap = i6;
        this.nodeMap = i7;
        this.ownedBy = mutabilityOwnership;
        this.buffer = objArr;
    }

    private final void accept(J4.h hVar, int i6, int i7) {
        hVar.invoke(this, Integer.valueOf(i7), Integer.valueOf(i6), Integer.valueOf(this.dataMap), Integer.valueOf(this.nodeMap));
        int i8 = this.nodeMap;
        while (i8 != 0) {
            int iLowestOneBit = Integer.lowestOneBit(i8);
            nodeAtIndex$runtime(nodeIndex$runtime(iLowestOneBit)).accept(hVar, (Integer.numberOfTrailingZeros(iLowestOneBit) << i7) + i6, i7 + 5);
            i8 -= iLowestOneBit;
        }
    }

    private final ModificationResult<K, V> asInsertResult() {
        return new ModificationResult<>(this, 1);
    }

    private final ModificationResult<K, V> asUpdateResult() {
        return new ModificationResult<>(this, 0);
    }

    private final Object[] bufferMoveEntryToNode(int i6, int i7, int i8, K k6, V v3, int i9, MutabilityOwnership mutabilityOwnership) {
        K kKeyAtIndex = keyAtIndex(i6);
        return TrieNodeKt.replaceEntryWithNode(this.buffer, i6, nodeIndex$runtime(i7) + 1, makeNode(kKeyAtIndex != null ? kKeyAtIndex.hashCode() : 0, kKeyAtIndex, valueAtKeyIndex(i6), i8, k6, v3, i9 + 5, mutabilityOwnership));
    }

    private final int calculateSize() {
        if (this.nodeMap == 0) {
            return this.buffer.length / 2;
        }
        int iBitCount = Integer.bitCount(this.dataMap);
        int length = this.buffer.length;
        for (int i6 = iBitCount * 2; i6 < length; i6++) {
            iBitCount += nodeAtIndex$runtime(i6).calculateSize();
        }
        return iBitCount;
    }

    private final boolean collisionContainsKey(K k6) {
        e eVarI0 = a.i0(2, a.l0(0, this.buffer.length));
        int i6 = eVarI0.f5676a;
        int i7 = eVarI0.f5677b;
        int i8 = eVarI0.f5678c;
        if ((i8 > 0 && i6 <= i7) || (i8 < 0 && i7 <= i6)) {
            while (!o.c(k6, this.buffer[i6])) {
                if (i6 != i7) {
                    i6 += i8;
                }
            }
            return true;
        }
        return false;
    }

    private final V collisionGet(K k6) {
        e eVarI0 = a.i0(2, a.l0(0, this.buffer.length));
        int i6 = eVarI0.f5676a;
        int i7 = eVarI0.f5677b;
        int i8 = eVarI0.f5678c;
        if ((i8 <= 0 || i6 > i7) && (i8 >= 0 || i7 > i6)) {
            return null;
        }
        while (!o.c(k6, keyAtIndex(i6))) {
            if (i6 == i7) {
                return null;
            }
            i6 += i8;
        }
        return valueAtKeyIndex(i6);
    }

    private final ModificationResult<K, V> collisionPut(K k6, V v3) {
        e eVarI0 = a.i0(2, a.l0(0, this.buffer.length));
        int i6 = eVarI0.f5676a;
        int i7 = eVarI0.f5677b;
        int i8 = eVarI0.f5678c;
        if ((i8 > 0 && i6 <= i7) || (i8 < 0 && i7 <= i6)) {
            while (!o.c(k6, keyAtIndex(i6))) {
                if (i6 != i7) {
                    i6 += i8;
                }
            }
            if (v3 == valueAtKeyIndex(i6)) {
                return null;
            }
            Object[] objArr = this.buffer;
            Object[] objArrCopyOf = Arrays.copyOf(objArr, objArr.length);
            o.g(objArrCopyOf, "copyOf(...)");
            objArrCopyOf[i6 + 1] = v3;
            return new TrieNode(0, 0, objArrCopyOf).asUpdateResult();
        }
        return new TrieNode(0, 0, TrieNodeKt.insertEntryAtIndex(this.buffer, 0, k6, v3)).asInsertResult();
    }

    private final TrieNode<K, V> collisionRemove(K k6) {
        e eVarI0 = a.i0(2, a.l0(0, this.buffer.length));
        int i6 = eVarI0.f5676a;
        int i7 = eVarI0.f5677b;
        int i8 = eVarI0.f5678c;
        if ((i8 > 0 && i6 <= i7) || (i8 < 0 && i7 <= i6)) {
            while (!o.c(k6, keyAtIndex(i6))) {
                if (i6 != i7) {
                    i6 += i8;
                }
            }
            return collisionRemoveEntryAtIndex(i6);
        }
        return this;
    }

    private final TrieNode<K, V> collisionRemoveEntryAtIndex(int i6) {
        Object[] objArr = this.buffer;
        if (objArr.length == 2) {
            return null;
        }
        return new TrieNode<>(0, 0, TrieNodeKt.removeEntryAtIndex(objArr, i6));
    }

    private final boolean elementsIdentityEquals(TrieNode<K, V> trieNode) {
        if (this == trieNode) {
            return true;
        }
        if (this.nodeMap != trieNode.nodeMap || this.dataMap != trieNode.dataMap) {
            return false;
        }
        int length = this.buffer.length;
        for (int i6 = 0; i6 < length; i6++) {
            if (this.buffer[i6] != trieNode.buffer[i6]) {
                return false;
            }
        }
        return true;
    }

    private final boolean hasNodeAt(int i6) {
        return (i6 & this.nodeMap) != 0;
    }

    private final TrieNode<K, V> insertEntryAt(int i6, K k6, V v3) {
        return new TrieNode<>(i6 | this.dataMap, this.nodeMap, TrieNodeKt.insertEntryAtIndex(this.buffer, entryKeyIndex$runtime(i6), k6, v3));
    }

    private final K keyAtIndex(int i6) {
        return (K) this.buffer[i6];
    }

    private final TrieNode<K, V> makeNode(int i6, K k6, V v3, int i7, K k7, V v6, int i8, MutabilityOwnership mutabilityOwnership) {
        if (i8 > 30) {
            return new TrieNode<>(0, 0, new Object[]{k6, v3, k7, v6}, mutabilityOwnership);
        }
        int iIndexSegment = TrieNodeKt.indexSegment(i6, i8);
        int iIndexSegment2 = TrieNodeKt.indexSegment(i7, i8);
        if (iIndexSegment != iIndexSegment2) {
            return new TrieNode<>((1 << iIndexSegment) | (1 << iIndexSegment2), 0, iIndexSegment < iIndexSegment2 ? new Object[]{k6, v3, k7, v6} : new Object[]{k7, v6, k6, v3}, mutabilityOwnership);
        }
        return new TrieNode<>(0, 1 << iIndexSegment, new Object[]{makeNode(i6, k6, v3, i7, k7, v6, i8 + 5, mutabilityOwnership)}, mutabilityOwnership);
    }

    private final TrieNode<K, V> moveEntryToNode(int i6, int i7, int i8, K k6, V v3, int i9) {
        return new TrieNode<>(this.dataMap ^ i7, this.nodeMap | i7, bufferMoveEntryToNode(i6, i7, i8, k6, v3, i9, null));
    }

    private final TrieNode<K, V> mutableCollisionPut(K k6, V v3, PersistentHashMapBuilder<K, V> persistentHashMapBuilder) {
        e eVarI0 = a.i0(2, a.l0(0, this.buffer.length));
        int i6 = eVarI0.f5676a;
        int i7 = eVarI0.f5677b;
        int i8 = eVarI0.f5678c;
        if ((i8 > 0 && i6 <= i7) || (i8 < 0 && i7 <= i6)) {
            while (!o.c(k6, keyAtIndex(i6))) {
                if (i6 != i7) {
                    i6 += i8;
                }
            }
            persistentHashMapBuilder.setOperationResult$runtime(valueAtKeyIndex(i6));
            if (this.ownedBy == persistentHashMapBuilder.getOwnership()) {
                this.buffer[i6 + 1] = v3;
                return this;
            }
            persistentHashMapBuilder.setModCount$runtime(persistentHashMapBuilder.getModCount$runtime() + 1);
            Object[] objArr = this.buffer;
            Object[] objArrCopyOf = Arrays.copyOf(objArr, objArr.length);
            o.g(objArrCopyOf, "copyOf(...)");
            objArrCopyOf[i6 + 1] = v3;
            return new TrieNode<>(0, 0, objArrCopyOf, persistentHashMapBuilder.getOwnership());
        }
        persistentHashMapBuilder.setSize(persistentHashMapBuilder.size() + 1);
        return new TrieNode<>(0, 0, TrieNodeKt.insertEntryAtIndex(this.buffer, 0, k6, v3), persistentHashMapBuilder.getOwnership());
    }

    /* JADX WARN: Multi-variable type inference failed */
    private final TrieNode<K, V> mutableCollisionPutAll(TrieNode<K, V> trieNode, DeltaCounter deltaCounter, MutabilityOwnership mutabilityOwnership) {
        CommonFunctionsKt.m197assert(this.nodeMap == 0);
        CommonFunctionsKt.m197assert(this.dataMap == 0);
        CommonFunctionsKt.m197assert(trieNode.nodeMap == 0);
        CommonFunctionsKt.m197assert(trieNode.dataMap == 0);
        Object[] objArr = this.buffer;
        Object[] objArrCopyOf = Arrays.copyOf(objArr, objArr.length + trieNode.buffer.length);
        o.g(objArrCopyOf, "copyOf(...)");
        int length = this.buffer.length;
        e eVarI0 = a.i0(2, a.l0(0, trieNode.buffer.length));
        int i6 = eVarI0.f5676a;
        int i7 = eVarI0.f5677b;
        int i8 = eVarI0.f5678c;
        if ((i8 > 0 && i6 <= i7) || (i8 < 0 && i7 <= i6)) {
            while (true) {
                if (collisionContainsKey(trieNode.buffer[i6])) {
                    deltaCounter.setCount(deltaCounter.getCount() + 1);
                } else {
                    Object[] objArr2 = trieNode.buffer;
                    objArrCopyOf[length] = objArr2[i6];
                    objArrCopyOf[length + 1] = objArr2[i6 + 1];
                    length += 2;
                }
                if (i6 == i7) {
                    break;
                }
                i6 += i8;
            }
        }
        if (length == this.buffer.length) {
            return this;
        }
        if (length == trieNode.buffer.length) {
            return trieNode;
        }
        if (length == objArrCopyOf.length) {
            return new TrieNode<>(0, 0, objArrCopyOf, mutabilityOwnership);
        }
        Object[] objArrCopyOf2 = Arrays.copyOf(objArrCopyOf, length);
        o.g(objArrCopyOf2, "copyOf(...)");
        return new TrieNode<>(0, 0, objArrCopyOf2, mutabilityOwnership);
    }

    private final TrieNode<K, V> mutableCollisionRemove(K k6, PersistentHashMapBuilder<K, V> persistentHashMapBuilder) {
        e eVarI0 = a.i0(2, a.l0(0, this.buffer.length));
        int i6 = eVarI0.f5676a;
        int i7 = eVarI0.f5677b;
        int i8 = eVarI0.f5678c;
        if ((i8 > 0 && i6 <= i7) || (i8 < 0 && i7 <= i6)) {
            while (!o.c(k6, keyAtIndex(i6))) {
                if (i6 != i7) {
                    i6 += i8;
                }
            }
            return mutableCollisionRemoveEntryAtIndex(i6, persistentHashMapBuilder);
        }
        return this;
    }

    private final TrieNode<K, V> mutableCollisionRemoveEntryAtIndex(int i6, PersistentHashMapBuilder<K, V> persistentHashMapBuilder) {
        persistentHashMapBuilder.setSize(persistentHashMapBuilder.size() - 1);
        persistentHashMapBuilder.setOperationResult$runtime(valueAtKeyIndex(i6));
        if (this.buffer.length == 2) {
            return null;
        }
        if (this.ownedBy != persistentHashMapBuilder.getOwnership()) {
            return new TrieNode<>(0, 0, TrieNodeKt.removeEntryAtIndex(this.buffer, i6), persistentHashMapBuilder.getOwnership());
        }
        this.buffer = TrieNodeKt.removeEntryAtIndex(this.buffer, i6);
        return this;
    }

    private final TrieNode<K, V> mutableInsertEntryAt(int i6, K k6, V v3, MutabilityOwnership mutabilityOwnership) {
        int iEntryKeyIndex$runtime = entryKeyIndex$runtime(i6);
        if (this.ownedBy != mutabilityOwnership) {
            return new TrieNode<>(i6 | this.dataMap, this.nodeMap, TrieNodeKt.insertEntryAtIndex(this.buffer, iEntryKeyIndex$runtime, k6, v3), mutabilityOwnership);
        }
        this.buffer = TrieNodeKt.insertEntryAtIndex(this.buffer, iEntryKeyIndex$runtime, k6, v3);
        this.dataMap = i6 | this.dataMap;
        return this;
    }

    private final TrieNode<K, V> mutableMoveEntryToNode(int i6, int i7, int i8, K k6, V v3, int i9, MutabilityOwnership mutabilityOwnership) {
        if (this.ownedBy != mutabilityOwnership) {
            return new TrieNode<>(this.dataMap ^ i7, i7 | this.nodeMap, bufferMoveEntryToNode(i6, i7, i8, k6, v3, i9, mutabilityOwnership), mutabilityOwnership);
        }
        this.buffer = bufferMoveEntryToNode(i6, i7, i8, k6, v3, i9, mutabilityOwnership);
        this.dataMap ^= i7;
        this.nodeMap |= i7;
        return this;
    }

    private final TrieNode<K, V> mutablePutAllFromOtherNodeCell(TrieNode<K, V> trieNode, int i6, int i7, DeltaCounter deltaCounter, PersistentHashMapBuilder<K, V> persistentHashMapBuilder) {
        if (hasNodeAt(i6)) {
            TrieNode<K, V> trieNodeNodeAtIndex$runtime = nodeAtIndex$runtime(nodeIndex$runtime(i6));
            if (trieNode.hasNodeAt(i6)) {
                return trieNodeNodeAtIndex$runtime.mutablePutAll(trieNode.nodeAtIndex$runtime(trieNode.nodeIndex$runtime(i6)), i7 + 5, deltaCounter, persistentHashMapBuilder);
            }
            if (!trieNode.hasEntryAt$runtime(i6)) {
                return trieNodeNodeAtIndex$runtime;
            }
            int iEntryKeyIndex$runtime = trieNode.entryKeyIndex$runtime(i6);
            K kKeyAtIndex = trieNode.keyAtIndex(iEntryKeyIndex$runtime);
            V vValueAtKeyIndex = trieNode.valueAtKeyIndex(iEntryKeyIndex$runtime);
            int size = persistentHashMapBuilder.size();
            TrieNode<K, V> trieNodeMutablePut = trieNodeNodeAtIndex$runtime.mutablePut(kKeyAtIndex != null ? kKeyAtIndex.hashCode() : 0, kKeyAtIndex, vValueAtKeyIndex, i7 + 5, persistentHashMapBuilder);
            if (persistentHashMapBuilder.size() == size) {
                deltaCounter.setCount(deltaCounter.getCount() + 1);
            }
            return trieNodeMutablePut;
        }
        if (!trieNode.hasNodeAt(i6)) {
            int iEntryKeyIndex$runtime2 = entryKeyIndex$runtime(i6);
            K kKeyAtIndex2 = keyAtIndex(iEntryKeyIndex$runtime2);
            V vValueAtKeyIndex2 = valueAtKeyIndex(iEntryKeyIndex$runtime2);
            int iEntryKeyIndex$runtime3 = trieNode.entryKeyIndex$runtime(i6);
            K kKeyAtIndex3 = trieNode.keyAtIndex(iEntryKeyIndex$runtime3);
            return makeNode(kKeyAtIndex2 != null ? kKeyAtIndex2.hashCode() : 0, kKeyAtIndex2, vValueAtKeyIndex2, kKeyAtIndex3 != null ? kKeyAtIndex3.hashCode() : 0, kKeyAtIndex3, trieNode.valueAtKeyIndex(iEntryKeyIndex$runtime3), i7 + 5, persistentHashMapBuilder.getOwnership());
        }
        TrieNode<K, V> trieNodeNodeAtIndex$runtime2 = trieNode.nodeAtIndex$runtime(trieNode.nodeIndex$runtime(i6));
        if (!hasEntryAt$runtime(i6)) {
            return trieNodeNodeAtIndex$runtime2;
        }
        int iEntryKeyIndex$runtime4 = entryKeyIndex$runtime(i6);
        K kKeyAtIndex4 = keyAtIndex(iEntryKeyIndex$runtime4);
        int i8 = i7 + 5;
        if (!trieNodeNodeAtIndex$runtime2.containsKey(kKeyAtIndex4 != null ? kKeyAtIndex4.hashCode() : 0, kKeyAtIndex4, i8)) {
            return trieNodeNodeAtIndex$runtime2.mutablePut(kKeyAtIndex4 != null ? kKeyAtIndex4.hashCode() : 0, kKeyAtIndex4, valueAtKeyIndex(iEntryKeyIndex$runtime4), i8, persistentHashMapBuilder);
        }
        deltaCounter.setCount(deltaCounter.getCount() + 1);
        return trieNodeNodeAtIndex$runtime2;
    }

    private final TrieNode<K, V> mutableRemoveEntryAtIndex(int i6, int i7, PersistentHashMapBuilder<K, V> persistentHashMapBuilder) {
        persistentHashMapBuilder.setSize(persistentHashMapBuilder.size() - 1);
        persistentHashMapBuilder.setOperationResult$runtime(valueAtKeyIndex(i6));
        if (this.buffer.length == 2) {
            return null;
        }
        if (this.ownedBy != persistentHashMapBuilder.getOwnership()) {
            return new TrieNode<>(i7 ^ this.dataMap, this.nodeMap, TrieNodeKt.removeEntryAtIndex(this.buffer, i6), persistentHashMapBuilder.getOwnership());
        }
        this.buffer = TrieNodeKt.removeEntryAtIndex(this.buffer, i6);
        this.dataMap ^= i7;
        return this;
    }

    private final TrieNode<K, V> mutableRemoveNodeAtIndex(int i6, int i7, MutabilityOwnership mutabilityOwnership) {
        Object[] objArr = this.buffer;
        if (objArr.length == 1) {
            return null;
        }
        if (this.ownedBy != mutabilityOwnership) {
            return new TrieNode<>(this.dataMap, i7 ^ this.nodeMap, TrieNodeKt.removeNodeAtIndex(objArr, i6), mutabilityOwnership);
        }
        this.buffer = TrieNodeKt.removeNodeAtIndex(objArr, i6);
        this.nodeMap ^= i7;
        return this;
    }

    private final TrieNode<K, V> mutableReplaceNode(TrieNode<K, V> trieNode, TrieNode<K, V> trieNode2, int i6, int i7, MutabilityOwnership mutabilityOwnership) {
        return trieNode2 == null ? mutableRemoveNodeAtIndex(i6, i7, mutabilityOwnership) : (this.ownedBy == mutabilityOwnership || trieNode != trieNode2) ? mutableUpdateNodeAtIndex(i6, trieNode2, mutabilityOwnership) : this;
    }

    private final TrieNode<K, V> mutableUpdateNodeAtIndex(int i6, TrieNode<K, V> trieNode, MutabilityOwnership mutabilityOwnership) {
        Object[] objArr = this.buffer;
        if (objArr.length == 1 && trieNode.buffer.length == 2 && trieNode.nodeMap == 0) {
            trieNode.dataMap = this.nodeMap;
            return trieNode;
        }
        if (this.ownedBy == mutabilityOwnership) {
            objArr[i6] = trieNode;
            return this;
        }
        Object[] objArrCopyOf = Arrays.copyOf(objArr, objArr.length);
        o.g(objArrCopyOf, "copyOf(...)");
        objArrCopyOf[i6] = trieNode;
        return new TrieNode<>(this.dataMap, this.nodeMap, objArrCopyOf, mutabilityOwnership);
    }

    private final TrieNode<K, V> mutableUpdateValueAtIndex(int i6, V v3, PersistentHashMapBuilder<K, V> persistentHashMapBuilder) {
        if (this.ownedBy == persistentHashMapBuilder.getOwnership()) {
            this.buffer[i6 + 1] = v3;
            return this;
        }
        persistentHashMapBuilder.setModCount$runtime(persistentHashMapBuilder.getModCount$runtime() + 1);
        Object[] objArr = this.buffer;
        Object[] objArrCopyOf = Arrays.copyOf(objArr, objArr.length);
        o.g(objArrCopyOf, "copyOf(...)");
        objArrCopyOf[i6 + 1] = v3;
        return new TrieNode<>(this.dataMap, this.nodeMap, objArrCopyOf, persistentHashMapBuilder.getOwnership());
    }

    private final TrieNode<K, V> removeEntryAtIndex(int i6, int i7) {
        Object[] objArr = this.buffer;
        if (objArr.length == 2) {
            return null;
        }
        return new TrieNode<>(i7 ^ this.dataMap, this.nodeMap, TrieNodeKt.removeEntryAtIndex(objArr, i6));
    }

    private final TrieNode<K, V> removeNodeAtIndex(int i6, int i7) {
        Object[] objArr = this.buffer;
        if (objArr.length == 1) {
            return null;
        }
        return new TrieNode<>(this.dataMap, i7 ^ this.nodeMap, TrieNodeKt.removeNodeAtIndex(objArr, i6));
    }

    private final TrieNode<K, V> replaceNode(TrieNode<K, V> trieNode, TrieNode<K, V> trieNode2, int i6, int i7) {
        return trieNode2 == null ? removeNodeAtIndex(i6, i7) : trieNode != trieNode2 ? updateNodeAtIndex(i6, i7, trieNode2) : this;
    }

    private final TrieNode<K, V> updateNodeAtIndex(int i6, int i7, TrieNode<K, V> trieNode) {
        Object[] objArr = trieNode.buffer;
        if (objArr.length != 2 || trieNode.nodeMap != 0) {
            Object[] objArr2 = this.buffer;
            Object[] objArrCopyOf = Arrays.copyOf(objArr2, objArr2.length);
            o.g(objArrCopyOf, "copyOf(...)");
            objArrCopyOf[i6] = trieNode;
            return new TrieNode<>(this.dataMap, this.nodeMap, objArrCopyOf);
        }
        if (this.buffer.length == 1) {
            trieNode.dataMap = this.nodeMap;
            return trieNode;
        }
        return new TrieNode<>(this.dataMap ^ i7, i7 ^ this.nodeMap, TrieNodeKt.replaceNodeWithEntry(this.buffer, i6, entryKeyIndex$runtime(i7), objArr[0], objArr[1]));
    }

    private final TrieNode<K, V> updateValueAtIndex(int i6, V v3) {
        Object[] objArr = this.buffer;
        Object[] objArrCopyOf = Arrays.copyOf(objArr, objArr.length);
        o.g(objArrCopyOf, "copyOf(...)");
        objArrCopyOf[i6 + 1] = v3;
        return new TrieNode<>(this.dataMap, this.nodeMap, objArrCopyOf);
    }

    private final V valueAtKeyIndex(int i6) {
        return (V) this.buffer[i6 + 1];
    }

    public final void accept$runtime(J4.h hVar) {
        accept(hVar, 0, 0);
    }

    public final boolean containsKey(int i6, K k6, int i7) {
        int iIndexSegment = 1 << TrieNodeKt.indexSegment(i6, i7);
        if (hasEntryAt$runtime(iIndexSegment)) {
            return o.c(k6, keyAtIndex(entryKeyIndex$runtime(iIndexSegment)));
        }
        if (!hasNodeAt(iIndexSegment)) {
            return false;
        }
        TrieNode<K, V> trieNodeNodeAtIndex$runtime = nodeAtIndex$runtime(nodeIndex$runtime(iIndexSegment));
        return i7 == 30 ? trieNodeNodeAtIndex$runtime.collisionContainsKey(k6) : trieNodeNodeAtIndex$runtime.containsKey(i6, k6, i7 + 5);
    }

    public final int entryCount$runtime() {
        return Integer.bitCount(this.dataMap);
    }

    public final int entryKeyIndex$runtime(int i6) {
        return Integer.bitCount((i6 - 1) & this.dataMap) * 2;
    }

    public final V get(int i6, K k6, int i7) {
        int iIndexSegment = 1 << TrieNodeKt.indexSegment(i6, i7);
        if (hasEntryAt$runtime(iIndexSegment)) {
            int iEntryKeyIndex$runtime = entryKeyIndex$runtime(iIndexSegment);
            if (o.c(k6, keyAtIndex(iEntryKeyIndex$runtime))) {
                return valueAtKeyIndex(iEntryKeyIndex$runtime);
            }
            return null;
        }
        if (!hasNodeAt(iIndexSegment)) {
            return null;
        }
        TrieNode<K, V> trieNodeNodeAtIndex$runtime = nodeAtIndex$runtime(nodeIndex$runtime(iIndexSegment));
        return i7 == 30 ? trieNodeNodeAtIndex$runtime.collisionGet(k6) : trieNodeNodeAtIndex$runtime.get(i6, k6, i7 + 5);
    }

    public final Object[] getBuffer$runtime() {
        return this.buffer;
    }

    public final boolean hasEntryAt$runtime(int i6) {
        return (i6 & this.dataMap) != 0;
    }

    public final TrieNode<K, V> mutablePut(int i6, K k6, V v3, int i7, PersistentHashMapBuilder<K, V> persistentHashMapBuilder) {
        PersistentHashMapBuilder<K, V> persistentHashMapBuilder2;
        TrieNode<K, V> trieNodeMutablePut;
        int iIndexSegment = 1 << TrieNodeKt.indexSegment(i6, i7);
        if (hasEntryAt$runtime(iIndexSegment)) {
            int iEntryKeyIndex$runtime = entryKeyIndex$runtime(iIndexSegment);
            if (o.c(k6, keyAtIndex(iEntryKeyIndex$runtime))) {
                persistentHashMapBuilder.setOperationResult$runtime(valueAtKeyIndex(iEntryKeyIndex$runtime));
                return valueAtKeyIndex(iEntryKeyIndex$runtime) == v3 ? this : mutableUpdateValueAtIndex(iEntryKeyIndex$runtime, v3, persistentHashMapBuilder);
            }
            persistentHashMapBuilder.setSize(persistentHashMapBuilder.size() + 1);
            return mutableMoveEntryToNode(iEntryKeyIndex$runtime, iIndexSegment, i6, k6, v3, i7, persistentHashMapBuilder.getOwnership());
        }
        if (!hasNodeAt(iIndexSegment)) {
            persistentHashMapBuilder.setSize(persistentHashMapBuilder.size() + 1);
            return mutableInsertEntryAt(iIndexSegment, k6, v3, persistentHashMapBuilder.getOwnership());
        }
        int iNodeIndex$runtime = nodeIndex$runtime(iIndexSegment);
        TrieNode<K, V> trieNodeNodeAtIndex$runtime = nodeAtIndex$runtime(iNodeIndex$runtime);
        if (i7 == 30) {
            trieNodeMutablePut = trieNodeNodeAtIndex$runtime.mutableCollisionPut(k6, v3, persistentHashMapBuilder);
            persistentHashMapBuilder2 = persistentHashMapBuilder;
        } else {
            persistentHashMapBuilder2 = persistentHashMapBuilder;
            trieNodeMutablePut = trieNodeNodeAtIndex$runtime.mutablePut(i6, k6, v3, i7 + 5, persistentHashMapBuilder2);
        }
        return trieNodeNodeAtIndex$runtime == trieNodeMutablePut ? this : mutableUpdateNodeAtIndex(iNodeIndex$runtime, trieNodeMutablePut, persistentHashMapBuilder2.getOwnership());
    }

    public final TrieNode<K, V> mutablePutAll(TrieNode<K, V> trieNode, int i6, DeltaCounter deltaCounter, PersistentHashMapBuilder<K, V> persistentHashMapBuilder) {
        if (this == trieNode) {
            deltaCounter.plusAssign(calculateSize());
            return this;
        }
        int i7 = i6;
        if (i7 > 30) {
            return mutableCollisionPutAll(trieNode, deltaCounter, persistentHashMapBuilder.getOwnership());
        }
        int i8 = this.nodeMap | trieNode.nodeMap;
        int i9 = this.dataMap;
        int i10 = trieNode.dataMap;
        int i11 = (i9 ^ i10) & (~i8);
        int i12 = i9 & i10;
        while (i12 != 0) {
            int iLowestOneBit = Integer.lowestOneBit(i12);
            if (o.c(keyAtIndex(entryKeyIndex$runtime(iLowestOneBit)), trieNode.keyAtIndex(trieNode.entryKeyIndex$runtime(iLowestOneBit)))) {
                i11 |= iLowestOneBit;
            } else {
                i8 |= iLowestOneBit;
            }
            i12 ^= iLowestOneBit;
        }
        int i13 = 0;
        if (!((i8 & i11) == 0)) {
            PreconditionsKt.throwIllegalStateException("Check failed.");
        }
        TrieNode<K, V> trieNode2 = (o.c(this.ownedBy, persistentHashMapBuilder.getOwnership()) && this.dataMap == i11 && this.nodeMap == i8) ? this : new TrieNode<>(i11, i8, new Object[Integer.bitCount(i8) + (Integer.bitCount(i11) * 2)]);
        int i14 = i8;
        int i15 = 0;
        while (i14 != 0) {
            int iLowestOneBit2 = Integer.lowestOneBit(i14);
            Object[] objArr = trieNode2.buffer;
            objArr[(objArr.length - 1) - i15] = mutablePutAllFromOtherNodeCell(trieNode, iLowestOneBit2, i7, deltaCounter, persistentHashMapBuilder);
            i15++;
            i14 ^= iLowestOneBit2;
            i7 = i6;
        }
        while (i11 != 0) {
            int iLowestOneBit3 = Integer.lowestOneBit(i11);
            int i16 = i13 * 2;
            if (trieNode.hasEntryAt$runtime(iLowestOneBit3)) {
                int iEntryKeyIndex$runtime = trieNode.entryKeyIndex$runtime(iLowestOneBit3);
                trieNode2.buffer[i16] = trieNode.keyAtIndex(iEntryKeyIndex$runtime);
                trieNode2.buffer[i16 + 1] = trieNode.valueAtKeyIndex(iEntryKeyIndex$runtime);
                if (hasEntryAt$runtime(iLowestOneBit3)) {
                    deltaCounter.setCount(deltaCounter.getCount() + 1);
                }
            } else {
                int iEntryKeyIndex$runtime2 = entryKeyIndex$runtime(iLowestOneBit3);
                trieNode2.buffer[i16] = keyAtIndex(iEntryKeyIndex$runtime2);
                trieNode2.buffer[i16 + 1] = valueAtKeyIndex(iEntryKeyIndex$runtime2);
            }
            i13++;
            i11 ^= iLowestOneBit3;
        }
        return elementsIdentityEquals(trieNode2) ? this : trieNode.elementsIdentityEquals(trieNode2) ? trieNode : trieNode2;
    }

    public final TrieNode<K, V> mutableRemove(int i6, K k6, int i7, PersistentHashMapBuilder<K, V> persistentHashMapBuilder) {
        int iIndexSegment = 1 << TrieNodeKt.indexSegment(i6, i7);
        if (hasEntryAt$runtime(iIndexSegment)) {
            int iEntryKeyIndex$runtime = entryKeyIndex$runtime(iIndexSegment);
            if (o.c(k6, keyAtIndex(iEntryKeyIndex$runtime))) {
                return mutableRemoveEntryAtIndex(iEntryKeyIndex$runtime, iIndexSegment, persistentHashMapBuilder);
            }
        } else if (hasNodeAt(iIndexSegment)) {
            int iNodeIndex$runtime = nodeIndex$runtime(iIndexSegment);
            TrieNode<K, V> trieNodeNodeAtIndex$runtime = nodeAtIndex$runtime(iNodeIndex$runtime);
            return mutableReplaceNode(trieNodeNodeAtIndex$runtime, i7 == 30 ? trieNodeNodeAtIndex$runtime.mutableCollisionRemove(k6, persistentHashMapBuilder) : trieNodeNodeAtIndex$runtime.mutableRemove(i6, k6, i7 + 5, persistentHashMapBuilder), iNodeIndex$runtime, iIndexSegment, persistentHashMapBuilder.getOwnership());
        }
        return this;
    }

    public final TrieNode<K, V> nodeAtIndex$runtime(int i6) {
        Object obj = this.buffer[i6];
        o.f(obj, "null cannot be cast to non-null type androidx.compose.runtime.external.kotlinx.collections.immutable.implementations.immutableMap.TrieNode<K of androidx.compose.runtime.external.kotlinx.collections.immutable.implementations.immutableMap.TrieNode, V of androidx.compose.runtime.external.kotlinx.collections.immutable.implementations.immutableMap.TrieNode>");
        return (TrieNode) obj;
    }

    public final int nodeIndex$runtime(int i6) {
        return (this.buffer.length - 1) - Integer.bitCount((i6 - 1) & this.nodeMap);
    }

    public final ModificationResult<K, V> put(int i6, K k6, V v3, int i7) {
        ModificationResult<K, V> modificationResultPut;
        int iIndexSegment = 1 << TrieNodeKt.indexSegment(i6, i7);
        if (hasEntryAt$runtime(iIndexSegment)) {
            int iEntryKeyIndex$runtime = entryKeyIndex$runtime(iIndexSegment);
            if (!o.c(k6, keyAtIndex(iEntryKeyIndex$runtime))) {
                return moveEntryToNode(iEntryKeyIndex$runtime, iIndexSegment, i6, k6, v3, i7).asInsertResult();
            }
            if (valueAtKeyIndex(iEntryKeyIndex$runtime) == v3) {
                return null;
            }
            return updateValueAtIndex(iEntryKeyIndex$runtime, v3).asUpdateResult();
        }
        if (!hasNodeAt(iIndexSegment)) {
            return insertEntryAt(iIndexSegment, k6, v3).asInsertResult();
        }
        int iNodeIndex$runtime = nodeIndex$runtime(iIndexSegment);
        TrieNode<K, V> trieNodeNodeAtIndex$runtime = nodeAtIndex$runtime(iNodeIndex$runtime);
        if (i7 == 30) {
            modificationResultPut = trieNodeNodeAtIndex$runtime.collisionPut(k6, v3);
            if (modificationResultPut == null) {
                return null;
            }
        } else {
            modificationResultPut = trieNodeNodeAtIndex$runtime.put(i6, k6, v3, i7 + 5);
            if (modificationResultPut == null) {
                return null;
            }
        }
        modificationResultPut.setNode(updateNodeAtIndex(iNodeIndex$runtime, iIndexSegment, modificationResultPut.getNode()));
        return modificationResultPut;
    }

    public final TrieNode<K, V> remove(int i6, K k6, int i7) {
        int iIndexSegment = 1 << TrieNodeKt.indexSegment(i6, i7);
        if (hasEntryAt$runtime(iIndexSegment)) {
            int iEntryKeyIndex$runtime = entryKeyIndex$runtime(iIndexSegment);
            if (o.c(k6, keyAtIndex(iEntryKeyIndex$runtime))) {
                return removeEntryAtIndex(iEntryKeyIndex$runtime, iIndexSegment);
            }
        } else if (hasNodeAt(iIndexSegment)) {
            int iNodeIndex$runtime = nodeIndex$runtime(iIndexSegment);
            TrieNode<K, V> trieNodeNodeAtIndex$runtime = nodeAtIndex$runtime(iNodeIndex$runtime);
            return replaceNode(trieNodeNodeAtIndex$runtime, i7 == 30 ? trieNodeNodeAtIndex$runtime.collisionRemove(k6) : trieNodeNodeAtIndex$runtime.remove(i6, k6, i7 + 5), iNodeIndex$runtime, iIndexSegment);
        }
        return this;
    }

    private final TrieNode<K, V> collisionRemove(K k6, V v3) {
        e eVarI0 = a.i0(2, a.l0(0, this.buffer.length));
        int i6 = eVarI0.f5676a;
        int i7 = eVarI0.f5677b;
        int i8 = eVarI0.f5678c;
        if ((i8 > 0 && i6 <= i7) || (i8 < 0 && i7 <= i6)) {
            while (true) {
                if (!o.c(k6, keyAtIndex(i6)) || !o.c(v3, valueAtKeyIndex(i6))) {
                    if (i6 == i7) {
                        break;
                    }
                    i6 += i8;
                } else {
                    return collisionRemoveEntryAtIndex(i6);
                }
            }
        }
        return this;
    }

    private final TrieNode<K, V> mutableCollisionRemove(K k6, V v3, PersistentHashMapBuilder<K, V> persistentHashMapBuilder) {
        e eVarI0 = a.i0(2, a.l0(0, this.buffer.length));
        int i6 = eVarI0.f5676a;
        int i7 = eVarI0.f5677b;
        int i8 = eVarI0.f5678c;
        if ((i8 > 0 && i6 <= i7) || (i8 < 0 && i7 <= i6)) {
            while (true) {
                if (!o.c(k6, keyAtIndex(i6)) || !o.c(v3, valueAtKeyIndex(i6))) {
                    if (i6 == i7) {
                        break;
                    }
                    i6 += i8;
                } else {
                    return mutableCollisionRemoveEntryAtIndex(i6, persistentHashMapBuilder);
                }
            }
        }
        return this;
    }

    public TrieNode(int i6, int i7, Object[] objArr) {
        this(i6, i7, objArr, null);
    }

    public final TrieNode<K, V> mutableRemove(int i6, K k6, V v3, int i7, PersistentHashMapBuilder<K, V> persistentHashMapBuilder) {
        TrieNode<K, V> trieNodeMutableRemove;
        int iIndexSegment = 1 << TrieNodeKt.indexSegment(i6, i7);
        if (hasEntryAt$runtime(iIndexSegment)) {
            int iEntryKeyIndex$runtime = entryKeyIndex$runtime(iIndexSegment);
            if (o.c(k6, keyAtIndex(iEntryKeyIndex$runtime)) && o.c(v3, valueAtKeyIndex(iEntryKeyIndex$runtime))) {
                return mutableRemoveEntryAtIndex(iEntryKeyIndex$runtime, iIndexSegment, persistentHashMapBuilder);
            }
        } else if (hasNodeAt(iIndexSegment)) {
            int iNodeIndex$runtime = nodeIndex$runtime(iIndexSegment);
            TrieNode<K, V> trieNodeNodeAtIndex$runtime = nodeAtIndex$runtime(iNodeIndex$runtime);
            if (i7 == 30) {
                trieNodeMutableRemove = trieNodeNodeAtIndex$runtime.mutableCollisionRemove(k6, v3, persistentHashMapBuilder);
            } else {
                trieNodeMutableRemove = trieNodeNodeAtIndex$runtime.mutableRemove(i6, k6, v3, i7 + 5, persistentHashMapBuilder);
            }
            return mutableReplaceNode(trieNodeNodeAtIndex$runtime, trieNodeMutableRemove, iNodeIndex$runtime, iIndexSegment, persistentHashMapBuilder.getOwnership());
        }
        return this;
    }

    public final TrieNode<K, V> remove(int i6, K k6, V v3, int i7) {
        TrieNode<K, V> trieNodeRemove;
        int iIndexSegment = 1 << TrieNodeKt.indexSegment(i6, i7);
        if (hasEntryAt$runtime(iIndexSegment)) {
            int iEntryKeyIndex$runtime = entryKeyIndex$runtime(iIndexSegment);
            if (o.c(k6, keyAtIndex(iEntryKeyIndex$runtime)) && o.c(v3, valueAtKeyIndex(iEntryKeyIndex$runtime))) {
                return removeEntryAtIndex(iEntryKeyIndex$runtime, iIndexSegment);
            }
        } else if (hasNodeAt(iIndexSegment)) {
            int iNodeIndex$runtime = nodeIndex$runtime(iIndexSegment);
            TrieNode<K, V> trieNodeNodeAtIndex$runtime = nodeAtIndex$runtime(iNodeIndex$runtime);
            if (i7 == 30) {
                trieNodeRemove = trieNodeNodeAtIndex$runtime.collisionRemove(k6, v3);
            } else {
                trieNodeRemove = trieNodeNodeAtIndex$runtime.remove(i6, k6, v3, i7 + 5);
            }
            return replaceNode(trieNodeNodeAtIndex$runtime, trieNodeRemove, iNodeIndex$runtime, iIndexSegment);
        }
        return this;
    }
}